Diff to HTML by rtfpessoa

Files changed (105) hide show

.github/CODEOWNERS +1 -0
.github/workflows/benchmarks.yml +1 -1
.github/workflows/test-install-scripts.yml +3 -3
.github/workflows/test.yml +17 -11
benchmarks/mempool-long-lived.py +1 -1
build_scripts/build_linux_deb-2-installer.sh +5 -0
build_scripts/npm_linux/package-lock.json +6 -6
build_scripts/npm_macos/package-lock.json +6 -6
build_scripts/npm_windows/package-lock.json +6 -6
chia/clvm/spend_sim.py +84 -45
chia/cmds/cmds_util.py +8 -1
chia/cmds/data.py +96 -5
chia/cmds/data_funcs.py +63 -9
chia/cmds/wallet.py +10 -3
chia/cmds/wallet_funcs.py +18 -17
chia/consensus/block_body_validation.py +11 -8
chia/consensus/constants.py +1 -1
chia/data_layer/data_layer.py +44 -6
chia/data_layer/data_layer_errors.py +4 -0
chia/data_layer/data_layer_util.py +229 -1
chia/data_layer/data_layer_wallet.py +8 -8
chia/data_layer/data_store.py +108 -6
chia/full_node/coin_store.py +30 -1
chia/full_node/mempool.py +14 -1
chia/full_node/mempool_manager.py +22 -12
chia/full_node/weight_proof.py +5 -10
chia/rpc/data_layer_rpc_api.py +124 -13
chia/rpc/data_layer_rpc_client.py +32 -6
chia/rpc/rpc_client.py +27 -11
chia/rpc/wallet_rpc_api.py +39 -8
chia/rpc/wallet_rpc_client.py +9 -23
chia/simulator/block_tools.py +4 -3
chia/types/blockchain_format/program.py +11 -2
chia/types/eligible_coin_spends.py +106 -3
chia/types/spend_bundle_conditions.py +4 -2
chia/util/condition_tools.py +1 -1
chia/util/generator_tools.py +1 -1
chia/util/initial-config.yaml +0 -2
chia/util/misc.py +87 -0
chia/util/streamable.py +6 -26
chia/wallet/cat_wallet/dao_cat_wallet.py +3 -3
chia/wallet/dao_wallet/dao_wallet.py +1 -1
chia/wallet/db_wallet/db_wallet_puzzles.py +2 -1
chia/wallet/did_wallet/did_wallet.py +14 -11
chia/wallet/key_val_store.py +3 -3
chia/wallet/puzzle_drivers.py +1 -1
chia/wallet/puzzles/clawback/drivers.py +6 -7
chia/wallet/puzzles/prefarm/make_prefarm_ph.py +1 -1
chia/wallet/puzzles/prefarm/spend_prefarm.py +5 -12
chia/wallet/trading/trade_store.py +2 -1
chia/wallet/util/wallet_sync_utils.py +4 -9
chia/wallet/wallet_blockchain.py +2 -4
chia/wallet/wallet_puzzle_store.py +8 -27
chia/wallet/wallet_transaction_store.py +51 -33
install.sh +9 -150
mypy-exclusions.txt +0 -1
setup.py +28 -29
tests/clvm/test_spend_sim.py +52 -4
tests/cmds/cmd_test_utils.py +1 -0
tests/cmds/test_cmds_util.py +27 -0
tests/cmds/wallet/test_wallet.py +55 -0
tests/conftest.py +62 -16
tests/core/consensus/test_block_creation.py +56 -3
tests/core/custom_types/test_coin.py +11 -11
tests/core/custom_types/test_spend_bundle.py +4 -3
tests/core/data_layer/test_data_rpc.py +868 -7
tests/core/data_layer/test_data_store.py +12 -12
tests/core/full_node/stores/test_coin_store.py +333 -3
tests/core/full_node/test_conditions.py +19 -32
tests/core/full_node/test_hint_management.py +9 -81
tests/core/mempool/test_mempool.py +2 -2
tests/core/mempool/test_mempool_manager.py +101 -43
tests/core/mempool/test_singleton_fast_forward.py +554 -3
tests/core/test_cost_calculation.py +5 -9
tests/core/test_merkle_set.py +62 -15
tests/core/test_program.py +49 -1
tests/core/util/test_streamable.py +1 -1
tests/ether.py +19 -0
tests/farmer_harvester/test_third_party_harvesters.py +470 -1
tests/generator/test_compression.py +6 -6
tests/generator/test_rom.py +2 -2
tests/process_benchmarks.py +0 -240
tests/process_junit.py +350 -1
tests/rpc/test_rpc_client.py +49 -0
tests/util/misc.py +248 -26
tests/util/test_condition_tools.py +2 -1
tests/util/test_misc.py +143 -2
tests/util/time_out_assert.py +104 -13
tests/wallet/cat_wallet/test_cat_wallet.py +785 -952
tests/wallet/cat_wallet/test_offer_lifecycle.py +2 -3
tests/wallet/cat_wallet/test_trades.py +384 -399
tests/wallet/dao_wallet/test_dao_clvm.py +11 -8
tests/wallet/did_wallet/test_did.py +6 -0
tests/wallet/nft_wallet/test_ownership_outer_puzzle.py +1 -1
tests/wallet/rpc/test_dl_wallet_rpc.py +56 -2
tests/wallet/rpc/test_wallet_rpc.py +52 -48
tests/wallet/simple_sync/test_simple_sync_protocol.py +524 -417
tests/wallet/test_debug_spend_bundle.py +4 -3
tests/wallet/test_sign_coin_spends.py +6 -6
tests/wallet/test_singleton.py +2 -4
tests/wallet/test_singleton_lifecycle_fast.py +53 -54
tests/wallet/test_singleton_store.py +4 -4
tests/wallet/test_wallet_node.py +1 -1
tests/wallet/test_wallet_state_manager.py +2 -2
tests/wallet/test_wallet_utils.py +13 -9

.github/CODEOWNERS CHANGED Viewed

         @@@ -2,3 -2,3 +2,4 @@@
 /.github/* @Chia-Network/actions-reviewers
 /PRETTY_GOOD_PRACTICES.md	@altendky @Chia-Network/required-reviewers
 /pylintrc	@altendky @Chia-Network/required-reviewers
+/tests/ether.py @altendky @Chia-Network/required-reviewers

.github/workflows/benchmarks.yml CHANGED Viewed

         @@@ -124,4 -124,4 +124,4 @@@ jobs
       - name: Add benchmark results to workflow summary
         if: always()
         run: |
-          python -m tests.process_benchmarks --xml junit-data/benchmarks.xml --markdown --link-prefix ${{ github.event.repository.html_url }}/blob/${{ github.sha }}/ --link-line-separator \#L >> "$GITHUB_STEP_SUMMARY"
+          python -m tests.process_junit --type benchmark --xml junit-data/benchmarks.xml --markdown --link-prefix ${{ github.event.repository.html_url }}/blob/${{ github.sha }}/ --link-line-separator \#L >> "$GITHUB_STEP_SUMMARY"

.github/workflows/test-install-scripts.yml CHANGED Viewed

         @@@ -131,7 -131,7 +131,7 @@@ jobs
         DEBIAN_FRONTEND: noninteractive
       run: |
         apt-get --yes update
-        apt-get install --yes git lsb-release sudo
+        apt-get install --yes git lsb-release sudo python3-venv
     - name: Prepare Fedora
       if: ${{ matrix.distribution.type == 'fedora' }}
         @@@ -141,7 -141,7 +141,7 @@@
     - name: Prepare Rocky
       if: ${{ matrix.distribution.type == 'rocky' }}
       run: |
-        yum install --assumeyes git sudo
+        yum install --assumeyes git sudo python39
     - name: Prepare Ubuntu
       if: ${{ matrix.distribution.type == 'ubuntu' }}
         @@@ -153,7 -153,7 +153,7 @@@
         apt-get install --yes software-properties-common
         add-apt-repository --yes ppa:git-core/ppa
         apt-get --yes update
-        apt-get install --yes git lsb-release sudo
+        apt-get install --yes git lsb-release sudo python3-venv
     - name: Add safe git directory
       run: git config --global --add safe.directory "$GITHUB_WORKSPACE"

.github/workflows/test.yml CHANGED Viewed

         @@@ -142,19 -139,18 +142,11 @@@ jobs
           path: junit-data/*
           if-no-files-found: error
-      - name: Publish JUnit results
-        if: always()
-        uses: actions/upload-artifact@v4
-        uses: actions/upload-artifact@v3
-        with:
-          name: junit-results
-          path: junit-results/*
-          if-no-files-found: error
       - name: Download Coverage
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
-          name: coverage-data
+          merge-multiple: true
+          pattern: coverage-data-*
           path: coverage-data
       - name: Set up ${{ matrix.python.name }}
         @@@ -169,6 -165,6 +161,20 @@@
       - uses: chia-network/actions/activate-venv@main
+      - name: Add time out assert results to workflow summary
+        if: always()
+        run: |
+          python -m tests.process_junit --limit 50 --type time_out_assert --xml junit-results/junit.xml --markdown --link-prefix ${{ github.event.repository.html_url }}/blob/${{ github.sha }}/ --link-line-separator \#L >> "$GITHUB_STEP_SUMMARY"
+          python -m tests.process_junit            --type time_out_assert --xml junit-results/junit.xml --markdown --link-prefix ${{ github.event.repository.html_url }}/blob/${{ github.sha }}/ --link-line-separator \#L >> junit-results/time_out_assert.md
+      - name: Publish JUnit results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: junit-results
+          path: junit-results/*
+          if-no-files-found: error
       - name: Coverage Processing
         run: |
           coverage combine --rcfile=.coveragerc --data-file=coverage-reports/.coverage coverage-data/

benchmarks/mempool-long-lived.py CHANGED Viewed

         @@@ -106,7 -101,7 +106,7 @@@ async def run_mempool_benchmark() -> No
         # add 10 transactions to the mempool
         for i in range(10):
-            coin = Coin(make_hash(height * 10 + i), IDENTITY_PUZZLE_HASH, height * 100000 + i * 100)
+            coin = Coin(make_hash(height * 10 + i), IDENTITY_PUZZLE_HASH, uint64(height * 100000 + i * 100))
             sb = make_spend_bundle(coin, height)
             # make this coin available via get_coin_record, which is called
             # by mempool_manager

build_scripts/build_linux_deb-2-installer.sh CHANGED Viewed

         @@@ -89,6 -87,6 +89,11 @@@ if [ "$PLATFORM" = "arm64" ]; the
   # @TODO Maybe versions of sub dependencies should be managed by gem lock file.
   # @TODO Once ruby 2.6 can be installed on `apt install ruby`, installing public_suffix below should be removed.
   sudo gem install public_suffix -v 4.0.7
+  # ERROR:  Error installing fpm:
+  #     The last version of dotenv (>= 0) to support your Ruby & RubyGems was 2.8.1. Try installing it with `gem install dotenv -v 2.8.1` and then running the current command again
+  #     dotenv requires Ruby version >= 3.0. The current ruby version is 2.7.0.0.
+  # @TODO Once ruby 3.0 can be installed on `apt install ruby`, installing dotenv below should be removed.
+  sudo gem install dotenv -v 2.8.1
   sudo gem install fpm
   echo USE_SYSTEM_FPM=true npx electron-builder build --linux deb --arm64 \
     --config.extraMetadata.name=chia-blockchain \

build_scripts/npm_linux/package-lock.json CHANGED Viewed

         @@@ -2823,9 -2823,9 +2823,9 @@@
       }
     },
     "node_modules/follow-redirects": {
-      "version": "1.15.2",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz",
-      "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==",
+      "version": "1.15.4",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.4.tgz",
+      "integrity": "sha512-Cr4D/5wlrb0z9dgERpUL3LrmPKVDsETIJhaCMeDfuFYcqa5bldGV6wBsAN6X/vxlXQtFBMrXdXxdL8CbDTGniw==",
       "funding": [
         {
           "type": "individual",
         @@@ -9471,9 -9471,9 +9471,9 @@@
       "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ=="
     },
     "follow-redirects": {
-      "version": "1.15.2",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz",
-      "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA=="
+      "version": "1.15.4",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.4.tgz",
+      "integrity": "sha512-Cr4D/5wlrb0z9dgERpUL3LrmPKVDsETIJhaCMeDfuFYcqa5bldGV6wBsAN6X/vxlXQtFBMrXdXxdL8CbDTGniw=="
     },
     "foreground-child": {
       "version": "3.1.1",

build_scripts/npm_macos/package-lock.json CHANGED Viewed

         @@@ -2838,9 -2838,9 +2838,9 @@@
       }
     },
     "node_modules/follow-redirects": {
-      "version": "1.15.2",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz",
-      "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==",
+      "version": "1.15.4",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.4.tgz",
+      "integrity": "sha512-Cr4D/5wlrb0z9dgERpUL3LrmPKVDsETIJhaCMeDfuFYcqa5bldGV6wBsAN6X/vxlXQtFBMrXdXxdL8CbDTGniw==",
       "funding": [
         {
           "type": "individual",
         @@@ -10080,9 -10080,9 +10080,9 @@@
       "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ=="
     },
     "follow-redirects": {
-      "version": "1.15.2",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz",
-      "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA=="
+      "version": "1.15.4",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.4.tgz",
+      "integrity": "sha512-Cr4D/5wlrb0z9dgERpUL3LrmPKVDsETIJhaCMeDfuFYcqa5bldGV6wBsAN6X/vxlXQtFBMrXdXxdL8CbDTGniw=="
     },
     "foreground-child": {
       "version": "3.1.1",

build_scripts/npm_windows/package-lock.json CHANGED Viewed

         @@@ -2730,9 -2730,9 +2730,9 @@@
       }
     },
     "node_modules/follow-redirects": {
-      "version": "1.15.2",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz",
-      "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==",
+      "version": "1.15.4",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.4.tgz",
+      "integrity": "sha512-Cr4D/5wlrb0z9dgERpUL3LrmPKVDsETIJhaCMeDfuFYcqa5bldGV6wBsAN6X/vxlXQtFBMrXdXxdL8CbDTGniw==",
       "funding": [
         {
           "type": "individual",
         @@@ -9291,9 -9291,9 +9291,9 @@@
       "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ=="
     },
     "follow-redirects": {
-      "version": "1.15.2",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz",
-      "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA=="
+      "version": "1.15.4",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.4.tgz",
+      "integrity": "sha512-Cr4D/5wlrb0z9dgERpUL3LrmPKVDsETIJhaCMeDfuFYcqa5bldGV6wBsAN6X/vxlXQtFBMrXdXxdL8CbDTGniw=="
     },
     "foreground-child": {
       "version": "3.1.1",

chia/clvm/spend_sim.py CHANGED Viewed

         @@@ -17,6 -14,6 +17,7 @@@ from chia.consensus.cost_calculator imp
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.bundle_tools import simple_solution_generator
 from chia.full_node.coin_store import CoinStore
+from chia.full_node.hint_store import HintStore
 from chia.full_node.mempool import Mempool
 from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions, get_puzzle_and_solution_for_coin
 from chia.full_node.mempool_manager import MempoolManager
         @@@ -34,6 -31,6 +35,7 @@@ from chia.util.errors import Err, Valid
 from chia.util.hash import std_hash
 from chia.util.ints import uint32, uint64
 from chia.util.streamable import Streamable, streamable
+from chia.wallet.util.compute_hints import HintedCoin, compute_spend_hints_and_additions
 """
 The purpose of this file is to provide a lightweight simulator for the testing of Chialisp smart contracts.
         @@@ -143,57 -141,56 +145,59 @@@ class SpendSim
     timestamp: uint64
     block_height: uint32
     defaults: ConsensusConstants
+    hint_store: HintStore
     @classmethod
-    async def create(
+    @contextlib.asynccontextmanager
+    async def managed(
         cls: Type[_T_SpendSim], db_path: Optional[Path] = None, defaults: ConsensusConstants = DEFAULT_CONSTANTS
-    ) -> _T_SpendSim:
+    ) -> AsyncIterator[_T_SpendSim]:
         self = cls()
         if db_path is None:
             uri = f"file:db_{random.randint(0, 99999999)}?mode=memory&cache=shared"
         else:
             uri = f"file:{db_path}"
-        self.db_wrapper = await DBWrapper2.create(database=uri, uri=True, reader_count=1, db_version=2)
-        self.coin_store = await CoinStore.create(self.db_wrapper)
-        self.mempool_manager = MempoolManager(self.coin_store.get_coin_record, defaults)
-        self.defaults = defaults
-        # Load the next data if there is any
-        async with self.db_wrapper.writer_maybe_transaction() as conn:
-            await conn.execute("CREATE TABLE IF NOT EXISTS block_data(data blob PRIMARY_KEY)")
-            cursor = await conn.execute("SELECT * from block_data")
-            row = await cursor.fetchone()
-            await cursor.close()
-            if row is not None:
-                store_data = SimStore.from_bytes(row[0])
-                self.timestamp = store_data.timestamp
-                self.block_height = store_data.block_height
-                self.block_records = store_data.block_records
-                self.blocks = store_data.blocks
-                self.mempool_manager.peak = self.block_records[-1]
-            else:
-                self.timestamp = uint64(1)
-                self.block_height = uint32(0)
-                self.block_records = []
-                self.blocks = []
-            return self
-    async def close(self) -> None:
-        async with self.db_wrapper.writer_maybe_transaction() as conn:
-            c = await conn.execute("DELETE FROM block_data")
-            await c.close()
-            c = await conn.execute(
-                "INSERT INTO block_data VALUES(?)",
-                (bytes(SimStore(self.timestamp, self.block_height, self.block_records, self.blocks)),),
-            )
-            await c.close()
-        await self.db_wrapper.close()
-    async def new_peak(self) -> None:
-        await self.mempool_manager.new_peak(self.block_records[-1], None)
+        async with DBWrapper2.managed(database=uri, uri=True, reader_count=1, db_version=2) as self.db_wrapper:
+            self.coin_store = await CoinStore.create(self.db_wrapper)
+            self.hint_store = await HintStore.create(self.db_wrapper)
+            self.mempool_manager = MempoolManager(self.coin_store.get_coin_records, defaults)
+            self.defaults = defaults
+            # Load the next data if there is any
+            async with self.db_wrapper.writer_maybe_transaction() as conn:
-                await conn.execute("CREATE TABLE IF NOT EXISTS block_data(data blob PRIMARY_KEY)")
+                await conn.execute("CREATE TABLE IF NOT EXISTS block_data(data blob PRIMARY KEY)")
+                cursor = await conn.execute("SELECT * from block_data")
+                row = await cursor.fetchone()
+                await cursor.close()
+                if row is not None:
+                    store_data = SimStore.from_bytes(row[0])
+                    self.timestamp = store_data.timestamp
+                    self.block_height = store_data.block_height
+                    self.block_records = store_data.block_records
+                    self.blocks = store_data.blocks
+                    self.mempool_manager.peak = self.block_records[-1]
+                else:
+                    self.timestamp = uint64(1)
+                    self.block_height = uint32(0)
+                    self.block_records = []
+                    self.blocks = []
+            try:
+                yield self
+            finally:
+                with anyio.CancelScope(shield=True):
+                    async with self.db_wrapper.writer_maybe_transaction() as conn:
+                        c = await conn.execute("DELETE FROM block_data")
+                        await c.close()
+                        c = await conn.execute(
+                            "INSERT INTO block_data VALUES(?)",
+                            (bytes(SimStore(self.timestamp, self.block_height, self.block_records, self.blocks)),),
+                        )
+                        await c.close()
+    async def new_peak(self, spent_coins_ids: Optional[List[bytes32]]) -> None:
+        await self.mempool_manager.new_peak(self.block_records[-1], spent_coins_ids)
     def new_coin_record(self, coin: Coin, coinbase: bool = False) -> CoinRecord:
         return CoinRecord(
         @@@ -268,12 -260,11 +272,19 @@@
                 if result is not None:
                     bundle, additions = result
                     generator_bundle = bundle
+                    for spend in generator_bundle.coin_spends:
+                        hint_dict, _ = compute_spend_hints_and_additions(spend)
+                        hints: List[Tuple[bytes32, bytes]] = []
+                        hint_obj: HintedCoin
+                        for coin_name, hint_obj in hint_dict.items():
+                            if hint_obj.hint is not None:
+                                hints.append((coin_name, bytes(hint_obj.hint)))
+                        await self.hint_store.add_hints(hints)
                     return_additions = additions
                     return_removals = bundle.removals()
+                    spent_coins_ids = [r.name() for r in return_removals]
                     await self.coin_store._add_coin_records([self.new_coin_record(addition) for addition in additions])
-                    await self.coin_store._set_spent([r.name() for r in return_removals], uint32(self.block_height + 1))
+                    await self.coin_store._set_spent(spent_coins_ids, uint32(self.block_height + 1))
         # SimBlockRecord is created
         generator: Optional[BlockGenerator] = await self.generate_transaction_generator(generator_bundle)
         @@@ -449,3 -440,3 +460,31 @@@ class SimClient
             return None
         else:
             return item.__dict__
+    async def get_coin_records_by_hint(
+        self,
+        hint: bytes32,
+        include_spent_coins: bool = True,
+        start_height: Optional[int] = None,
+        end_height: Optional[int] = None,
+    ) -> List[CoinRecord]:
+        """
+        Retrieves coins by hint, by default returns unspent coins.
+        """
+        names: List[bytes32] = await self.service.hint_store.get_coin_ids(hint)
+        kwargs: Dict[str, Any] = {
+            "include_spent_coins": False,
+            "names": names,
+        }
+        if start_height:
+            kwargs["start_height"] = uint32(start_height)
+        if end_height:
+            kwargs["end_height"] = uint32(end_height)
+        if include_spent_coins:
+            kwargs["include_spent_coins"] = include_spent_coins
+        coin_records = await self.service.coin_store.get_coin_records_by_names(**kwargs)
+        return coin_records

chia/cmds/cmds_util.py CHANGED Viewed

         @@@ -32,6 -32,6 +32,7 @@@ from chia.wallet.transaction_record imp
 from chia.wallet.util.tx_config import CoinSelectionConfig, CoinSelectionConfigLoader, TXConfig, TXConfigLoader
 NODE_TYPES: Dict[str, Type[RpcClient]] = {
+    "base": RpcClient,
     "farmer": FarmerRpcClient,
     "wallet": WalletRpcClient,
     "full_node": FullNodeRpcClient,
         @@@ -41,6 -41,6 +42,7 @@@
 }
 node_config_section_names: Dict[Type[RpcClient], str] = {
+    RpcClient: "base",
     FarmerRpcClient: "farmer",
     WalletRpcClient: "wallet",
     FullNodeRpcClient: "full_node",
         @@@ -92,6 -92,6 +94,7 @@@ async def get_any_service_client
     rpc_port: Optional[int] = None,
     root_path: Optional[Path] = None,
     consume_errors: bool = True,
+    use_ssl: bool = True,
 ) -> AsyncIterator[Tuple[_T_RpcClient, Dict[str, Any]]]:
     """
     Yields a tuple with a RpcClient for the applicable node type a dictionary of the node's configuration,
         @@@ -112,7 -112,7 +115,11 @@@
     if rpc_port is None:
         rpc_port = config[node_type]["rpc_port"]
     # select node client type based on string
-    node_client = await client_type.create(self_hostname, uint16(rpc_port), root_path, config)
+    if use_ssl:
+        node_client = await client_type.create(self_hostname, uint16(rpc_port), root_path=root_path, net_config=config)
+    else:
+        node_client = await client_type.create(self_hostname, uint16(rpc_port), root_path=None, net_config=None)
     try:
         # check if we can connect to node
         await validate_client_connection(node_client, node_type, rpc_port, consume_errors)

chia/cmds/data.py CHANGED Viewed

         @@@ -51,14 -51,14 +51,15 @@@ def create_changelist_option() -> Calla
     )
-def create_key_option() -> Callable[[FC], FC]:
+def create_key_option(multiple: bool = False) -> Callable[[FC], FC]:
     return click.option(
         "-k",
         "--key",
-        "key_string",
+        "key_strings" if multiple else "key_string",
         help="str representing the key",
         type=str,
         required=True,
+        multiple=multiple,
     )
         @@@ -106,6 -106,6 +107,25 @@@ def create_fee_option() -> Callable[[FC
     )
+def create_page_option() -> Callable[[FC], FC]:
+    return click.option(
+        "-p",
+        "--page",
+        help="Enables pagination of the output and requests a specific page.",
+        type=int,
+        required=False,
+    )
+def create_max_page_size_option() -> Callable[[FC], FC]:
+    return click.option(
+        "--max-page-size",
+        help="Set how many bytes to be included in a page, if pagination is enabled.",
+        type=int,
+        required=False,
+    )
 @data_cmd.command("create_data_store", help="Create a new data store")
 @create_rpc_port_option()
 @create_fee_option()
         @@@ -171,15 -171,15 +191,19 @@@ def update_data_store
 @click.option("-r", "--root_hash", help="The hexadecimal root hash", type=str, required=False)
 @create_rpc_port_option()
 @options.create_fingerprint()
+@create_page_option()
+@create_max_page_size_option()
 def get_keys(
     id: str,
     root_hash: Optional[str],
     data_rpc_port: int,
     fingerprint: Optional[int],
+    page: Optional[int],
+    max_page_size: Optional[int],
 ) -> None:
     from chia.cmds.data_funcs import get_keys_cmd
-    run(get_keys_cmd(data_rpc_port, id, root_hash, fingerprint=fingerprint))
+    run(get_keys_cmd(data_rpc_port, id, root_hash, fingerprint=fingerprint, page=page, max_page_size=max_page_size))
 @data_cmd.command("get_keys_values", help="Get all keys and values for a given store")
         @@@ -187,15 -187,15 +211,23 @@@
 @click.option("-r", "--root_hash", help="The hexadecimal root hash", type=str, required=False)
 @create_rpc_port_option()
 @options.create_fingerprint()
+@create_page_option()
+@create_max_page_size_option()
 def get_keys_values(
     id: str,
     root_hash: Optional[str],
     data_rpc_port: int,
     fingerprint: Optional[int],
+    page: Optional[int],
+    max_page_size: Optional[int],
 ) -> None:
     from chia.cmds.data_funcs import get_keys_values_cmd
-    run(get_keys_values_cmd(data_rpc_port, id, root_hash, fingerprint=fingerprint))
+    run(
+        get_keys_values_cmd(
+            data_rpc_port, id, root_hash, fingerprint=fingerprint, page=page, max_page_size=max_page_size
+        )
+    )
 @data_cmd.command("get_root", help="Get the published root hash value for a given store")
         @@@ -275,16 -275,16 +307,30 @@@ def unsubscribe
 @click.option("-hash_2", "--hash_2", help="Final hash", type=str)
 @create_rpc_port_option()
 @options.create_fingerprint()
+@create_page_option()
+@create_max_page_size_option()
 def get_kv_diff(
     id: str,
     hash_1: str,
     hash_2: str,
     data_rpc_port: int,
     fingerprint: Optional[int],
+    page: Optional[int],
+    max_page_size: Optional[int],
 ) -> None:
     from chia.cmds.data_funcs import get_kv_diff_cmd
-    run(get_kv_diff_cmd(rpc_port=data_rpc_port, store_id=id, hash_1=hash_1, hash_2=hash_2, fingerprint=fingerprint))
+    run(
+        get_kv_diff_cmd(
+            rpc_port=data_rpc_port,
+            store_id=id,
+            hash_1=hash_1,
+            hash_2=hash_2,
+            fingerprint=fingerprint,
+            page=page,
+            max_page_size=max_page_size,
+        )
+    )
 @data_cmd.command("get_root_history", help="Get all changes of a singleton")
         @@@ -530,3 -529,3 +576,48 @@@ def wallet_log_in
             fingerprint=fingerprint,
         )
     )
+@data_cmd.command(
+    "get_proof",
+    help="Obtains a merkle proof of inclusion for a given key",
+)
+@create_data_store_id_option()
+@create_rpc_port_option()
+@create_key_option(multiple=True)
+@options.create_fingerprint()
+def get_proof(
+    id: str,
+    key_strings: List[str],
+    data_rpc_port: int,
+    fingerprint: Optional[int],
+) -> None:
+    from chia.cmds.data_funcs import get_proof_cmd
+    store_id = bytes32.from_hexstr(id)
+    run(get_proof_cmd(rpc_port=data_rpc_port, store_id=store_id, fingerprint=fingerprint, key_strings=key_strings))
+@data_cmd.command(
+    "verify_proof",
+    help="Verifies a merkle proof of inclusion",
+)
+@click.option(
+    "-p",
+    "--proof",
+    "proof_string",
+    help="Proof to validate in JSON format.",
+    type=str,
+)
+@create_rpc_port_option()
+@options.create_fingerprint()
+def verify_proof(
+    proof_string: str,
+    data_rpc_port: int,
+    fingerprint: Optional[int],
+) -> None:
+    from chia.cmds.data_funcs import verify_proof_cmd
+    proof_dict = json.loads(proof_string)
+    run(verify_proof_cmd(rpc_port=data_rpc_port, fingerprint=fingerprint, proof=proof_dict))

chia/cmds/data_funcs.py CHANGED Viewed

         @@@ -83,26 -83,26 +83,42 @@@ async def get_keys_cmd
     store_id: str,
     root_hash: Optional[str],
     fingerprint: Optional[int],
-) -> None:
+    page: Optional[int],
+    max_page_size: Optional[int],
+    root_path: Optional[Path] = None,
+) -> Dict[str, Any]:
     store_id_bytes = bytes32.from_hexstr(store_id)
     root_hash_bytes = None if root_hash is None else bytes32.from_hexstr(root_hash)
-    async with get_client(rpc_port=rpc_port, fingerprint=fingerprint) as (client, _):
-        res = await client.get_keys(store_id=store_id_bytes, root_hash=root_hash_bytes)
+    res = dict()
+    async with get_client(rpc_port=rpc_port, fingerprint=fingerprint, root_path=root_path) as (client, _):
+        res = await client.get_keys(
+            store_id=store_id_bytes, root_hash=root_hash_bytes, page=page, max_page_size=max_page_size
+        )
         print(json.dumps(res, indent=4, sort_keys=True))
+    return res
 async def get_keys_values_cmd(
     rpc_port: Optional[int],
     store_id: str,
     root_hash: Optional[str],
     fingerprint: Optional[int],
-) -> None:
+    page: Optional[int],
+    max_page_size: Optional[int],
+    root_path: Optional[Path] = None,
+) -> Dict[str, Any]:
     store_id_bytes = bytes32.from_hexstr(store_id)
     root_hash_bytes = None if root_hash is None else bytes32.from_hexstr(root_hash)
-    async with get_client(rpc_port=rpc_port, fingerprint=fingerprint) as (client, _):
-        res = await client.get_keys_values(store_id=store_id_bytes, root_hash=root_hash_bytes)
+    res = dict()
+    async with get_client(rpc_port=rpc_port, fingerprint=fingerprint, root_path=root_path) as (client, _):
+        res = await client.get_keys_values(
+            store_id=store_id_bytes, root_hash=root_hash_bytes, page=page, max_page_size=max_page_size
+        )
         print(json.dumps(res, indent=4, sort_keys=True))
+    return res
 async def get_root_cmd(
     rpc_port: Optional[int],
         @@@ -157,14 -157,14 +173,23 @@@ async def get_kv_diff_cmd
     hash_1: str,
     hash_2: str,
     fingerprint: Optional[int],
-) -> None:
+    page: Optional[int],
+    max_page_size: Optional[int],
+    root_path: Optional[Path] = None,
+) -> Dict[str, Any]:
     store_id_bytes = bytes32.from_hexstr(store_id)
     hash_1_bytes = bytes32.from_hexstr(hash_1)
     hash_2_bytes = bytes32.from_hexstr(hash_2)
-    async with get_client(rpc_port=rpc_port, fingerprint=fingerprint) as (client, _):
-        res = await client.get_kv_diff(store_id=store_id_bytes, hash_1=hash_1_bytes, hash_2=hash_2_bytes)
+    res = dict()
+    async with get_client(rpc_port=rpc_port, fingerprint=fingerprint, root_path=root_path) as (client, _):
+        res = await client.get_kv_diff(
+            store_id=store_id_bytes, hash_1=hash_1_bytes, hash_2=hash_2_bytes, page=page, max_page_size=max_page_size
+        )
         print(json.dumps(res, indent=4, sort_keys=True))
+    return res
 async def get_root_history_cmd(
     rpc_port: Optional[int],
         @@@ -286,3 -286,3 +311,32 @@@ async def clear_pending_roots
         print(json.dumps(result, indent=4, sort_keys=True))
     return result
+async def get_proof_cmd(
+    store_id: bytes32,
+    key_strings: List[str],
+    rpc_port: Optional[int],
+    root_path: Optional[Path] = None,
+    fingerprint: Optional[int] = None,
+) -> Dict[str, Any]:
+    result = dict()
+    async with get_client(rpc_port=rpc_port, fingerprint=fingerprint, root_path=root_path) as (client, _):
+        result = await client.get_proof(store_id=store_id, keys=[hexstr_to_bytes(key) for key in key_strings])
+        print(json.dumps(result, indent=4, sort_keys=True))
+    return result
+async def verify_proof_cmd(
+    proof: Dict[str, Any],
+    rpc_port: Optional[int],
+    root_path: Optional[Path] = None,
+    fingerprint: Optional[int] = None,
+) -> Dict[str, Any]:
+    result = dict()
+    async with get_client(rpc_port=rpc_port, fingerprint=fingerprint, root_path=root_path) as (client, _):
+        result = await client.verify_proof(proof=proof)
+        print(json.dumps(result, indent=4, sort_keys=True))
+    return result

chia/cmds/wallet.py CHANGED Viewed

         @@@ -1,6 -1,6 +1,7 @@@
 from __future__ import annotations
 import asyncio
+import pathlib
 from decimal import Decimal
 from typing import List, Optional, Sequence
         @@@ -441,9 -441,10 +442,15 @@@ def add_token_cmd(wallet_rpc_port: Opti
     "-r",
     "--request",
     help="A wallet id of an asset to receive and the amount you wish to receive (formatted like wallet_id:amount)",
-    required=True,
     multiple=True,
 )
-@click.option("-p", "--filepath", help="The path to write the generated offer file to", required=True)
+@click.option(
+    "-p",
+    "--filepath",
+    help="The path to write the generated offer file to",
+    required=True,
+    type=click.Path(dir_okay=False, writable=True, path_type=pathlib.Path),
+)
 @click.option(
     "-m", "--fee", help="A fee to add to the offer when it gets taken, in XCH", default="0", show_default=True
 )
         @@@ -459,10 -459,9 +466,10 @@@ def make_offer_cmd
     fingerprint: int,
     offer: Sequence[str],
     request: Sequence[str],
-    filepath: str,
+    filepath: pathlib.Path,
     fee: str,
     reuse: bool,
+    override: bool,
 ) -> None:
     from .wallet_funcs import make_offer

chia/cmds/wallet_funcs.py CHANGED Viewed

         @@@ -413,7 -412,7 +413,7 @@@ async def make_offer
     d_fee: Decimal,
     offers: Sequence[str],
     requests: Sequence[str],
-    filepath: str,
+    filepath: pathlib.Path,
     reuse_puzhash: Optional[bool],
 ) -> None:
     async with get_wallet_client(wallet_rpc_port, fp) as (wallet_client, fingerprint, config):
         @@@ -550,23 -549,23 +550,24 @@@
                 cli_confirm("Confirm (y/n): ", "Not creating offer...")
-                offer, trade_record = await wallet_client.create_offer_for_ids(
-                    offer_dict,
-                    driver_dict=driver_dict,
-                    fee=fee,
-                    tx_config=CMDTXConfigLoader(
-                        reuse_puzhash=reuse_puzhash,
-                    ).to_tx_config(units["chia"], config, fingerprint),
-                )
-                if offer is not None:
-                    with open(pathlib.Path(filepath), "w") as file:
-                        file.write(offer.to_bech32())
-                    print(f"Created offer with ID {trade_record.trade_id}")
-                    print(
-                        f"Use chia wallet get_offers --id " f"{trade_record.trade_id} -f {fingerprint} to view status"
+                with filepath.open(mode="w") as file:
+                    offer, trade_record = await wallet_client.create_offer_for_ids(
+                        offer_dict,
+                        driver_dict=driver_dict,
+                        fee=fee,
+                        tx_config=CMDTXConfigLoader(
+                            reuse_puzhash=reuse_puzhash,
+                        ).to_tx_config(units["chia"], config, fingerprint),
                     )
-                else:
-                    print("Error creating offer")
+                    if offer is not None:
+                        file.write(offer.to_bech32())
+                        print(f"Created offer with ID {trade_record.trade_id}")
+                        print(
+                            f"Use chia wallet get_offers --id "
+                            f"{trade_record.trade_id} -f {fingerprint} to view status"
+                        )
+                    else:
+                        print("Error creating offer")
 def timestamp_to_time(timestamp: int) -> str:

chia/consensus/block_body_validation.py CHANGED Viewed

         @@@ -106,24 -70,15 +106,22 @@@ class ForkInfo
             assert block.foliage_transaction_block is not None
             timestamp = block.foliage_transaction_block.timestamp
             for spend in npc_result.conds.spends:
-                self.removals_since_fork.add(bytes32(spend.coin_id))
-                for puzzle_hash, amount, _ in spend.create_coin:
+                self.removals_since_fork[bytes32(spend.coin_id)] = ForkRem(bytes32(spend.puzzle_hash), height)
+                for puzzle_hash, amount, hint in spend.create_coin:
                     coin = Coin(bytes32(spend.coin_id), bytes32(puzzle_hash), uint64(amount))
-                    self.additions_since_fork[coin.name()] = ForkAdd(
-                        coin, uint32(height), uint64(timestamp), hint, False
-                    )
-                    self.additions_since_fork[coin.name()] = (coin, height, timestamp)
+                    self.additions_since_fork[coin.name()] = ForkAdd(coin, height, timestamp, hint, False)
         for coin in block.get_included_reward_coins():
             assert block.foliage_transaction_block is not None
             timestamp = block.foliage_transaction_block.timestamp
             assert coin.name() not in self.additions_since_fork
-            self.additions_since_fork[coin.name()] = ForkAdd(coin, uint32(block.height), uint64(timestamp), None, True)
-            self.additions_since_fork[coin.name()] = (coin, block.height, timestamp)
+            self.additions_since_fork[coin.name()] = ForkAdd(coin, block.height, timestamp, None, True)
+    def rollback(self, header_hash: bytes32, height: int) -> None:
+        assert height <= self.peak_height
+        self.peak_height = height
+        self.peak_hash = header_hash
+        self.additions_since_fork = {k: v for k, v in self.additions_since_fork.items() if v.confirmed_height <= height}
+        self.removals_since_fork = {k: v for k, v in self.removals_since_fork.items() if v.height <= height}
 async def validate_block_body(

chia/consensus/constants.py CHANGED Viewed

         @@@ -48,7 -48,7 +48,7 @@@ class ConsensusConstants
     # Size of mempool = 10x the size of block
     MEMPOOL_BLOCK_BUFFER: int
     # Max coin amount uint(1 << 64). This allows coin amounts to fit in 64 bits. This is around 18M chia.
-    MAX_COIN_AMOUNT: int
+    MAX_COIN_AMOUNT: uint64
     # Max block cost in clvm cost units
     MAX_BLOCK_COST_CLVM: int
     # Cost per byte of generator program

chia/data_layer/data_layer.py CHANGED Viewed

         @@@ -32,7 -32,7 +32,10 @@@ from chia.data_layer.data_layer_errors
 from chia.data_layer.data_layer_util import (
     DiffData,
     InternalNode,
+    KeysPaginationData,
+    KeysValuesPaginationData,
     KeyValue,
+    KVDiffPaginationData,
     Layer,
     Offer,
     OfferStore,
         @@@ -312,14 -319,14 +315,12 @@@ class DataLayer
             node = await self.data_store.get_node_by_key(tree_id=store_id, key=key, root_hash=root_hash)
             return node.hash
-    async def get_value(self, store_id: bytes32, key: bytes, root_hash: Optional[bytes32] = None) -> Optional[bytes]:
+    async def get_value(self, store_id: bytes32, key: bytes, root_hash: Optional[bytes32] = None) -> bytes:
         await self._update_confirmation_status(tree_id=store_id)
         async with self.data_store.transaction():
+            # this either returns the node or raises an exception
             res = await self.data_store.get_node_by_key(tree_id=store_id, key=key, root_hash=root_hash)
-            if res is None:
-                self.log.error("Failed to fetch key")
-                return None
             return res.value
     async def get_keys_values(self, store_id: bytes32, root_hash: Optional[bytes32]) -> List[TerminalNode]:
         @@@ -330,12 -337,12 +331,40 @@@
             self.log.error("Failed to fetch keys values")
         return res
+    async def get_keys_values_paginated(
+        self,
+        store_id: bytes32,
+        root_hash: Optional[bytes32],
+        page: int,
+        max_page_size: Optional[int] = None,
+    ) -> KeysValuesPaginationData:
+        await self._update_confirmation_status(tree_id=store_id)
+        if max_page_size is None:
+            max_page_size = 40 * 1024 * 1024
+        res = await self.data_store.get_keys_values_paginated(store_id, page, max_page_size, root_hash)
+        return res
     async def get_keys(self, store_id: bytes32, root_hash: Optional[bytes32]) -> List[bytes]:
         await self._update_confirmation_status(tree_id=store_id)
         res = await self.data_store.get_keys(store_id, root_hash)
         return res
+    async def get_keys_paginated(
+        self,
+        store_id: bytes32,
+        root_hash: Optional[bytes32],
+        page: int,
+        max_page_size: Optional[int] = None,
+    ) -> KeysPaginationData:
+        await self._update_confirmation_status(tree_id=store_id)
+        if max_page_size is None:
+            max_page_size = 40 * 1024 * 1024
+        res = await self.data_store.get_keys_paginated(store_id, page, max_page_size, root_hash)
+        return res
     async def get_ancestors(self, node_hash: bytes32, store_id: bytes32) -> List[InternalNode]:
         await self._update_confirmation_status(tree_id=store_id)
         @@@ -635,13 -639,13 +664,14 @@@
                         else:
                             self.log.debug(f"uploaded to uploader {uploader}")
-    async def subscribe(self, store_id: bytes32, urls: List[str]) -> None:
+    async def subscribe(self, store_id: bytes32, urls: List[str]) -> Subscription:
         parsed_urls = [url.rstrip("/") for url in urls]
         subscription = Subscription(store_id, [ServerInfo(url, 0, 0) for url in parsed_urls])
         await self.wallet_rpc.dl_track_new(subscription.tree_id)
         async with self.subscription_lock:
             await self.data_store.subscribe(subscription)
         self.log.info(f"Done adding subscription: {subscription.tree_id}")
+        return subscription
     async def remove_subscriptions(self, store_id: bytes32, urls: List[str]) -> None:
         parsed_urls = [url.rstrip("/") for url in urls]
         @@@ -711,6 -704,6 +741,13 @@@
     async def get_kv_diff(self, tree_id: bytes32, hash_1: bytes32, hash_2: bytes32) -> Set[DiffData]:
         return await self.data_store.get_kv_diff(tree_id, hash_1, hash_2)
+    async def get_kv_diff_paginated(
+        self, tree_id: bytes32, hash_1: bytes32, hash_2: bytes32, page: int, max_page_size: Optional[int] = None
+    ) -> KVDiffPaginationData:
+        if max_page_size is None:
+            max_page_size = 40 * 1024 * 1024
+        return await self.data_store.get_kv_diff_paginated(tree_id, page, max_page_size, hash_1, hash_2)
     async def periodically_manage_data(self) -> None:
         manage_data_interval = self.config.get("manage_data_interval", 60)
         while not self._shut_down:
         @@@ -743,7 -736,7 +780,8 @@@
             for local_id in local_tree_ids:
                 if local_id not in subscription_tree_ids:
                     try:
-                        await self.subscribe(local_id, [])
+                        subscription = await self.subscribe(local_id, [])
+                        subscriptions.insert(0, subscription)
                     except Exception as e:
                         self.log.info(
                             f"Can't subscribe to locally stored {local_id}: {type(e)} {e} {traceback.format_exc()}"

chia/data_layer/data_layer_errors.py CHANGED Viewed

         @@@ -42,5 -42,5 +42,9 @@@ class OfferIntegrityError(Exception)
     pass
+class ProofIntegrityError(Exception):
+    pass
 class LauncherCoinNotFoundError(Exception):
     pass

chia/data_layer/data_layer_util.py CHANGED Viewed

         @@@ -9,15 -9,15 +9,19 @@@ from typing import TYPE_CHECKING, Any,
 import aiosqlite as aiosqlite
 from typing_extensions import final
+from chia.data_layer.data_layer_errors import ProofIntegrityError
+from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.db_wrapper import DBWrapper2
-from chia.util.ints import uint64
+from chia.util.ints import uint8, uint64
 from chia.util.streamable import Streamable, streamable
+from chia.wallet.db_wallet.db_wallet_puzzles import create_host_fullpuz
 if TYPE_CHECKING:
     from chia.data_layer.data_store import DataStore
+    from chia.wallet.wallet_node import WalletNode
 def internal_hash(left_hash: bytes32, right_hash: bytes32) -> bytes32:
         @@@ -43,10 -43,6 +47,39 @@@ def leaf_hash(key: bytes, value: bytes
     return Program.to((key, value)).get_tree_hash()  # type: ignore[no-any-return]
+def key_hash(key: bytes) -> bytes32:
+    return Program.to(key).get_tree_hash()  # type: ignore[no-any-return]
+@dataclasses.dataclass(frozen=True)
+class PaginationData:
+    total_pages: int
+    total_bytes: int
+    hashes: List[bytes32]
+def get_hashes_for_page(page: int, lengths: Dict[bytes32, int], max_page_size: int) -> PaginationData:
+    current_page = 0
+    current_page_size = 0
+    total_bytes = 0
+    hashes: List[bytes32] = []
+    for hash, length in sorted(lengths.items(), key=lambda x: (-x[1], x[0])):
+        if length > max_page_size:
+            raise RuntimeError(
+                f"Cannot paginate data, item size is larger than max page size: {length} {max_page_size}"
+            )
+        total_bytes += length
+        if current_page_size + length <= max_page_size:
+            current_page_size += length
+        else:
+            current_page += 1
+            current_page_size = length
+        if current_page == page:
+            hashes.append(hash)
+    return PaginationData(current_page + 1, total_bytes, hashes)
 async def _debug_dump(db: DBWrapper2, description: str = "") -> None:
     async with db.reader() as reader:
         cursor = await reader.execute("SELECT name FROM sqlite_master WHERE type='table';")
         @@@ -729,9 -725,3 +762,194 @@@ class PluginStatus
 class InsertResult:
     node_hash: bytes32
     root: Root
+@dataclasses.dataclass(frozen=True)
+class UnsubscribeData:
+    tree_id: bytes32
+    retain_data: bool
+@dataclasses.dataclass(frozen=True)
+class KeysValuesCompressed:
+    keys_values_hashed: Dict[bytes32, bytes32]
+    key_hash_to_length: Dict[bytes32, int]
+    leaf_hash_to_length: Dict[bytes32, int]
+    root_hash: Optional[bytes32]
+@dataclasses.dataclass(frozen=True)
+class KeysPaginationData:
+    total_pages: int
+    total_bytes: int
+    keys: List[bytes]
+    root_hash: Optional[bytes32]
+@dataclasses.dataclass(frozen=True)
+class KeysValuesPaginationData:
+    total_pages: int
+    total_bytes: int
+    keys_values: List[TerminalNode]
+    root_hash: Optional[bytes32]
+@dataclasses.dataclass(frozen=True)
+class KVDiffPaginationData:
+    total_pages: int
+    total_bytes: int
+    kv_diff: List[DiffData]
+#
+# GetProof and VerifyProof support classes
+#
+@streamable
+@dataclasses.dataclass(frozen=True)
+class ProofLayer(Streamable):
+    # This class is basically Layer but streamable
+    other_hash_side: uint8
+    other_hash: bytes32
+    combined_hash: bytes32
+@streamable
+@dataclasses.dataclass(frozen=True)
+class HashOnlyProof(Streamable):
+    key_clvm_hash: bytes32
+    value_clvm_hash: bytes32
+    node_hash: bytes32
+    layers: List[ProofLayer]
+    def root(self) -> bytes32:
+        if len(self.layers) == 0:
+            return self.node_hash
+        return self.layers[-1].combined_hash
+    @classmethod
+    def from_key_value(cls, key: bytes, value: bytes, node_hash: bytes32, layers: List[ProofLayer]) -> HashOnlyProof:
+        return cls(
+            key_clvm_hash=Program.to(key).get_tree_hash(),
+            value_clvm_hash=Program.to(value).get_tree_hash(),
+            node_hash=node_hash,
+            layers=layers,
+        )
+@streamable
+@dataclasses.dataclass(frozen=True)
+class KeyValueHashes(Streamable):
+    key_clvm_hash: bytes32
+    value_clvm_hash: bytes32
+@streamable
+@dataclasses.dataclass(frozen=True)
+class ProofResultInclusions(Streamable):
+    store_id: bytes32
+    inclusions: List[KeyValueHashes]
+@streamable
+@dataclasses.dataclass(frozen=True)
+class GetProofRequest(Streamable):
+    store_id: bytes32
+    keys: List[bytes]
+@streamable
+@dataclasses.dataclass(frozen=True)
+class StoreProofsHashes(Streamable):
+    store_id: bytes32
+    proofs: List[HashOnlyProof]
+@streamable
+@dataclasses.dataclass(frozen=True)
+class DLProof(Streamable):
+    store_proofs: StoreProofsHashes
+    coin_id: bytes32
+    inner_puzzle_hash: bytes32
+@streamable
+@dataclasses.dataclass(frozen=True)
+class GetProofResponse(Streamable):
+    proof: DLProof
+    success: bool
+@streamable
+@dataclasses.dataclass(frozen=True)
+class VerifyProofResponse(Streamable):
+    verified_clvm_hashes: ProofResultInclusions
+    current_root: bool
+    success: bool
+def dl_verify_proof_internal(dl_proof: DLProof, puzzle_hash: bytes32) -> List[KeyValueHashes]:
+    """Verify a proof of inclusion for a DL singleton"""
+    verified_keys: List[KeyValueHashes] = []
+    for reference_proof in dl_proof.store_proofs.proofs:
+        inner_puz_hash = dl_proof.inner_puzzle_hash
+        host_fullpuz_program = create_host_fullpuz(
+            inner_puz_hash, reference_proof.root(), dl_proof.store_proofs.store_id
+        )
+        expected_puzzle_hash = host_fullpuz_program.get_tree_hash_precalc(inner_puz_hash)
+        if puzzle_hash != expected_puzzle_hash:
+            raise ProofIntegrityError(
+                "Invalid Proof: incorrect puzzle hash: expected:"
+                f"{expected_puzzle_hash.hex()} received: {puzzle_hash.hex()}"
+            )
+        proof = ProofOfInclusion(
+            node_hash=reference_proof.node_hash,
+            layers=[
+                ProofOfInclusionLayer(
+                    other_hash_side=Side(layer.other_hash_side),
+                    other_hash=layer.other_hash,
+                    combined_hash=layer.combined_hash,
+                )
+                for layer in reference_proof.layers
+            ],
+        )
+        leaf_hash = internal_hash(left_hash=reference_proof.key_clvm_hash, right_hash=reference_proof.value_clvm_hash)
+        if leaf_hash != proof.node_hash:
+            raise ProofIntegrityError("Invalid Proof: node hash does not match key and value")
+        if not proof.valid():
+            raise ProofIntegrityError("Invalid Proof: invalid proof of inclusion found")
+        verified_keys.append(
+            KeyValueHashes(key_clvm_hash=reference_proof.key_clvm_hash, value_clvm_hash=reference_proof.value_clvm_hash)
+        )
+    return verified_keys
+async def dl_verify_proof(
+    request: Dict[str, Any],
+    wallet_node: WalletNode,
+    peer: WSChiaConnection,
+) -> Dict[str, Any]:
+    """Verify a proof of inclusion for a DL singleton"""
+    dlproof = DLProof.from_json_dict(request)
+    coin_id = dlproof.coin_id
+    coin_states = await wallet_node.get_coin_state([coin_id], peer=peer)
+    if len(coin_states) == 0:
+        raise ProofIntegrityError(f"Invalid Proof: No DL singleton found at coin id: {coin_id.hex()}")
+    verified_keys = dl_verify_proof_internal(dlproof, coin_states[0].coin.puzzle_hash)
+    response = VerifyProofResponse(
+        verified_clvm_hashes=ProofResultInclusions(dlproof.store_proofs.store_id, verified_keys),
+        success=True,
+        current_root=coin_states[0].spent_height is None,
+    )
+    return response.to_json_dict()

chia/data_layer/data_layer_wallet.py CHANGED Viewed

         @@@ -859,7 -864,7 +859,7 @@@ class DataLayerWallet
         puzzle = parent_spend.puzzle_reveal
         solution = parent_spend.solution
-        matched, _ = match_dl_singleton(puzzle.to_program())
+        matched, _ = match_dl_singleton(puzzle)
         if matched:
             self.log.info(f"DL singleton removed: {parent_spend.coin}")
             singleton_record: Optional[SingletonRecord] = await self.wallet_state_manager.dl_store.get_singleton_record(
         @@@ -1184,7 -1193,7 +1184,7 @@@
             assert txs[0].spend_bundle is not None
             dl_spend: CoinSpend = next(
-                cs for cs in txs[0].spend_bundle.coin_spends if match_dl_singleton(cs.puzzle_reveal.to_program())[0]
+                cs for cs in txs[0].spend_bundle.coin_spends if match_dl_singleton(cs.puzzle_reveal)[0]
             )
             all_other_spends: List[CoinSpend] = [cs for cs in txs[0].spend_bundle.coin_spends if cs != dl_spend]
             dl_solution: Program = dl_spend.solution.to_program()
         @@@ -1226,18 -1240,18 +1226,18 @@@
         singleton_to_root: Dict[bytes32, bytes32] = {}
         all_parent_ids: List[bytes32] = [cs.coin.parent_coin_info for cs in offer.coin_spends()]
         for spend in offer.coin_spends():
-            matched, curried_args = match_dl_singleton(spend.puzzle_reveal.to_program())
+            matched, curried_args = match_dl_singleton(spend.puzzle_reveal)
             if matched and spend.coin.name() not in all_parent_ids:
-                innerpuz, root, launcher_id = curried_args
+                innerpuz, root_prg, launcher_id = curried_args
                 singleton_struct = launcher_to_struct(bytes32(launcher_id.as_python())).get_tree_hash()
-                singleton_to_root[singleton_struct] = bytes32(root.as_python())
+                singleton_to_root[singleton_struct] = bytes32(root_prg.as_python())
                 singleton_to_innerpuzhash[singleton_struct] = innerpuz.get_tree_hash()
         # Create all of the new solutions
         new_spends: List[CoinSpend] = []
         for spend in offer.coin_spends():
             solution = spend.solution.to_program()
-            if match_dl_singleton(spend.puzzle_reveal.to_program())[0]:
+            if match_dl_singleton(spend.puzzle_reveal)[0]:
                 try:
                     graftroot: Program = solution.at("rrffrf")
                 except EvalError:
         @@@ -1295,7 -1312,7 +1295,7 @@@
         summary: Dict[str, Any] = {"offered": []}
         for spend in offer.coin_spends():
             solution = spend.solution.to_program()
-            matched, curried_args = match_dl_singleton(spend.puzzle_reveal.to_program())
+            matched, curried_args = match_dl_singleton(spend.puzzle_reveal)
             if matched:
                 try:
                     graftroot: Program = solution.at("rrffrf")
         @@@ -1306,7 -1323,7 +1306,7 @@@
                     child_spend: CoinSpend = next(
                         cs for cs in offer.coin_spends() if cs.coin.parent_coin_info == spend.coin.name()
                     )
-                    _, child_curried_args = match_dl_singleton(child_spend.puzzle_reveal.to_program())
+                    _, child_curried_args = match_dl_singleton(child_spend.puzzle_reveal)
                     singleton_summary = {
                         "launcher_id": list(curried_args)[2].as_python().hex(),
                         "new_root": list(child_curried_args)[1].as_python().hex(),

chia/data_layer/data_store.py CHANGED Viewed

         @@@ -15,6 -14,6 +15,10 @@@ from chia.data_layer.data_layer_util im
     DiffData,
     InsertResult,
     InternalNode,
+    KeysPaginationData,
+    KeysValuesCompressed,
+    KeysValuesPaginationData,
+    KVDiffPaginationData,
     Node,
     NodeType,
     OperationType,
         @@@ -27,8 -26,7 +31,9 @@@
     Status,
     Subscription,
     TerminalNode,
+    get_hashes_for_page,
     internal_hash,
+    key_hash,
     leaf_hash,
     row_to_node,
 )
         @@@ -728,26 -723,6 +733,106 @@@ class DataStore
         return terminal_nodes
+    async def get_keys_values_compressed(
+        self, tree_id: bytes32, root_hash: Optional[bytes32] = None
-    ) -> Dict[bytes32, bytes32]:
+    ) -> KeysValuesCompressed:
+        async with self.db_wrapper.reader() as reader:
+            if root_hash is None:
+                root = await self.get_tree_root(tree_id=tree_id)
+                root_hash = root.node_hash
+            cursor = await self.get_keys_values_cursor(reader, root_hash)
-            kv_compressed: Dict[bytes32, bytes32] = {}
+            keys_values_hashed: Dict[bytes32, bytes32] = {}
+            key_hash_to_length: Dict[bytes32, int] = {}
+            leaf_hash_to_length: Dict[bytes32, int] = {}
+            async for row in cursor:
+                if row["depth"] > 62:
+                    raise Exception("Tree depth exceeded 62, unable to guarantee left-to-right node order.")
+                node = row_to_node(row=row)
+                if not isinstance(node, TerminalNode):
+                    raise Exception(f"Unexpected internal node found: {node.hash.hex()}")
-                kv_compressed[key_hash(node.key)] = leaf_hash(node.key, node.value)
+                keys_values_hashed[key_hash(node.key)] = leaf_hash(node.key, node.value)
+                key_hash_to_length[key_hash(node.key)] = len(node.key)
+                leaf_hash_to_length[leaf_hash(node.key, node.value)] = len(node.key) + len(node.value)
+            return KeysValuesCompressed(keys_values_hashed, key_hash_to_length, leaf_hash_to_length, root_hash)
+    async def get_keys_paginated(
+        self, tree_id: bytes32, page: int, max_page_size: int, root_hash: Optional[bytes32] = None
+    ) -> KeysPaginationData:
+        keys_values_compressed = await self.get_keys_values_compressed(tree_id, root_hash)
+        pagination_data = get_hashes_for_page(page, keys_values_compressed.key_hash_to_length, max_page_size)
+        keys: List[bytes] = []
+        for hash in pagination_data.hashes:
+            leaf_hash = keys_values_compressed.keys_values_hashed[hash]
+            node = await self.get_node(leaf_hash)
+            assert isinstance(node, TerminalNode)
+            keys.append(node.key)
+        return KeysPaginationData(
+            pagination_data.total_pages,
+            pagination_data.total_bytes,
+            keys,
+            keys_values_compressed.root_hash,
+        )
+    async def get_keys_values_paginated(
+        self, tree_id: bytes32, page: int, max_page_size: int, root_hash: Optional[bytes32] = None
+    ) -> KeysValuesPaginationData:
+        keys_values_compressed = await self.get_keys_values_compressed(tree_id, root_hash)
+        pagination_data = get_hashes_for_page(page, keys_values_compressed.leaf_hash_to_length, max_page_size)
+        keys_values: List[TerminalNode] = []
+        for hash in pagination_data.hashes:
+            node = await self.get_node(hash)
+            assert isinstance(node, TerminalNode)
+            keys_values.append(node)
+        return KeysValuesPaginationData(
+            pagination_data.total_pages,
+            pagination_data.total_bytes,
+            keys_values,
+            keys_values_compressed.root_hash,
+        )
-            return kv_compressed
+    async def get_kv_diff_paginated(
+        self, tree_id: bytes32, page: int, max_page_size: int, hash1: bytes32, hash2: bytes32
+    ) -> KVDiffPaginationData:
+        old_pairs = await self.get_keys_values_compressed(tree_id, hash1)
+        new_pairs = await self.get_keys_values_compressed(tree_id, hash2)
+        if len(old_pairs.keys_values_hashed) == 0 and hash1 != bytes32([0] * 32):
+            return KVDiffPaginationData(1, 0, [])
+        if len(new_pairs.keys_values_hashed) == 0 and hash2 != bytes32([0] * 32):
+            return KVDiffPaginationData(1, 0, [])
+        old_pairs_leaf_hashes = {v for v in old_pairs.keys_values_hashed.values()}
+        new_pairs_leaf_hashes = {v for v in new_pairs.keys_values_hashed.values()}
+        insertions = {k for k in new_pairs_leaf_hashes if k not in old_pairs_leaf_hashes}
+        deletions = {k for k in old_pairs_leaf_hashes if k not in new_pairs_leaf_hashes}
+        lengths = {}
+        for hash in insertions:
+            lengths[hash] = new_pairs.leaf_hash_to_length[hash]
+        for hash in deletions:
+            lengths[hash] = old_pairs.leaf_hash_to_length[hash]
+        pagination_data = get_hashes_for_page(page, lengths, max_page_size)
+        kv_diff: List[DiffData] = []
+        for hash in pagination_data.hashes:
+            node = await self.get_node(hash)
+            assert isinstance(node, TerminalNode)
+            if hash in insertions:
+                kv_diff.append(DiffData(OperationType.INSERT, node.key, node.value))
+            else:
+                kv_diff.append(DiffData(OperationType.DELETE, node.key, node.value))
+        return KVDiffPaginationData(
+            pagination_data.total_pages,
+            pagination_data.total_bytes,
+            kv_diff,
+        )
     async def get_node_type(self, node_hash: bytes32) -> NodeType:
         async with self.db_wrapper.reader() as reader:
             cursor = await reader.execute(
         @@@ -1258,7 -1085,7 +1343,8 @@@
             if old_root.node_hash is None:
                 hint_keys_values = {}
             else:
-                hint_keys_values = await self.get_keys_values_compressed(tree_id, root_hash=root_hash)
-                hint_keys_values = await self.get_keys_values_dict(tree_id, root_hash=root_hash)
+                kv_compressed = await self.get_keys_values_compressed(tree_id, root_hash=root_hash)
+                hint_keys_values = kv_compressed.keys_values_hashed
             intermediate_root: Optional[Root] = old_root
             for change in changelist:

chia/full_node/coin_store.py CHANGED Viewed

         @@@ -588,33 -495,3 +588,33 @@@ class CoinStore
                 raise ValueError(
                     f"Invalid operation to set spent, total updates {rows_updated} expected {len(coin_names)}"
                 )
+    # Lookup the most recent unspent lineage that matches a puzzle hash
+    async def get_unspent_lineage_info_for_puzzle_hash(self, puzzle_hash: bytes32) -> Optional[UnspentLineageInfo]:
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            async with conn.execute(
+                "SELECT unspent.coin_name, "
+                "unspent.amount, "
+                "unspent.coin_parent, "
+                "parent.amount, "
+                "parent.coin_parent "
-                "FROM coin_record AS unspent "
+                "FROM coin_record AS unspent INDEXED BY coin_puzzle_hash "
+                "LEFT JOIN coin_record AS parent ON unspent.coin_parent = parent.coin_name "
+                "WHERE unspent.spent_index = 0 "
+                "AND parent.spent_index > 0 "
+                "AND unspent.puzzle_hash = ? "
+                "AND parent.puzzle_hash = unspent.puzzle_hash",
+                (puzzle_hash,),
+            ) as cursor:
+                rows = list(await cursor.fetchall())
+                if len(rows) != 1:
+                    log.debug("Expected 1 unspent with puzzle hash %s, but found %s", puzzle_hash.hex(), len(rows))
+                    return None
+                coin_id, coin_amount, parent_id, parent_amount, parent_parent_id = rows[0]
+                return UnspentLineageInfo(
+                    coin_id=bytes32(coin_id),
+                    coin_amount=int_from_bytes(coin_amount),
+                    parent_id=bytes32(parent_id),
+                    parent_amount=int_from_bytes(parent_amount),
+                    parent_parent_id=bytes32(parent_parent_id),
+                )

chia/full_node/mempool.py CHANGED Viewed

         @@@ -26,20 -25,6 +26,20 @@@ from chia.util.misc import to_batche
 log = logging.getLogger(__name__)
+# Maximum number of mempool items that can be skipped (not considered) during
+# the creation of a block bundle. An item is skipped if it won't fit in the
+# block we're trying to create.
-MAX_SKIPPED_ITEMS = 20
+MAX_SKIPPED_ITEMS = 10
+# Threshold after which we stop including mempool items with eligible spends
+# during the creation of a block bundle. We do that to avoid spending too much
+# time on potentially expensive items.
+PRIORITY_TX_THRESHOLD = 3
+# Typical cost of a standard XCH spend. It's used as a heuristic to help
+# determine how close to the block size limit we're willing to go.
+MIN_COST_THRESHOLD = 6_000_000
 # We impose a limit on the fee a single transaction can pay in order to have the
 # sum of all fees in the mempool be less than 2^63. That's the limit of sqlite's
 # integers, which we rely on for computing fee per cost as well as the fee sum

chia/full_node/mempool_manager.py CHANGED Viewed

         @@@ -168,7 -156,6 +168,9 @@@ class MempoolManager
     seen_cache_size: int
     peak: Optional[BlockRecordProtocol]
     mempool: Mempool
+    _worker_queue_size: int
+    max_block_clvm_cost: uint64
+    max_tx_clvm_cost: uint64
     def __init__(
         self,
         @@@ -177,6 -164,6 +179,7 @@@
         multiprocessing_context: Optional[BaseContext] = None,
         *,
         single_threaded: bool = False,
+        max_tx_clvm_cost: Optional[uint64] = None,
     ):
         self.constants: ConsensusConstants = consensus_constants
         @@@ -190,8 -177,8 +193,11 @@@
         # spends.
         self.nonzero_fee_minimum_fpc = 5
-        BLOCK_SIZE_LIMIT_FACTOR = 0.5
+        BLOCK_SIZE_LIMIT_FACTOR = 0.6
         self.max_block_clvm_cost = uint64(self.constants.MAX_BLOCK_COST_CLVM * BLOCK_SIZE_LIMIT_FACTOR)
+        self.max_tx_clvm_cost = (
+            max_tx_clvm_cost if max_tx_clvm_cost is not None else uint64(self.constants.MAX_BLOCK_COST_CLVM // 2)
+        )
         self.mempool_max_total_cost = int(self.constants.MAX_BLOCK_COST_CLVM * self.constants.MEMPOOL_BLOCK_BUFFER)
         # Transactions that were unable to enter mempool, used for retry. (they were invalid)
         @@@ -300,18 -280,14 +306,18 @@@
         assert self.peak is not None
-        err, cached_result_bytes, new_cache_entries = await asyncio.get_running_loop().run_in_executor(
-            self.pool,
-            validate_clvm_and_signature,
-            new_spend_bytes,
-            self.max_block_clvm_cost,
-            self.constants,
-            self.peak.height,
-        )
+        self._worker_queue_size += 1
+        try:
+            err, cached_result_bytes, new_cache_entries, duration = await asyncio.get_running_loop().run_in_executor(
+                self.pool,
+                validate_clvm_and_signature,
+                new_spend_bytes,
-                self.max_block_clvm_cost,
+                self.max_tx_clvm_cost,
+                self.constants,
+                self.peak.height,
+            )
+        finally:
+            self._worker_queue_size -= 1
         if err is not None:
             raise ValidationError(err)
         @@@ -434,7 -398,7 +440,7 @@@
             removal_names.add(coin_id)
             spend_additions = []
             for puzzle_hash, amount, _ in spend.create_coin:
-                child_coin = Coin(coin_id, puzzle_hash, amount)
+                child_coin = Coin(coin_id, puzzle_hash, uint64(amount))
                 spend_additions.append(child_coin)
                 additions_dict[child_coin.name()] = child_coin
                 addition_amount = addition_amount + child_coin.amount
         @@@ -513,7 -450,7 +519,7 @@@
         if cost == 0:
             return Err.UNKNOWN, None, []
-        if cost > self.max_block_clvm_cost:
+        if cost > self.max_tx_clvm_cost:
             return Err.BLOCK_COST_EXCEEDS_MAX, None, []
         # this is not very likely to happen, but it's here to ensure SQLite

chia/full_node/weight_proof.py CHANGED Viewed

         @@@ -707,10 -707,10 +707,10 @@@ def _create_sub_epoch_data
 ) -> SubEpochData:
     reward_chain_hash: bytes32 = sub_epoch_summary.reward_chain_hash
     #  Number of subblocks overflow in previous slot
-    previous_sub_epoch_overflows = uint8(sub_epoch_summary.num_blocks_overflow)  # total in sub epoch - expected
-    previous_sub_epoch_overflows: uint8 = sub_epoch_summary.num_blocks_overflow  # total in sub epoch - expected
+    previous_sub_epoch_overflows = sub_epoch_summary.num_blocks_overflow  # total in sub epoch - expected
     #  New work difficulty and iterations per sub-slot
-    sub_slot_iters: Optional[int] = sub_epoch_summary.new_sub_slot_iters
-    new_difficulty: Optional[int] = sub_epoch_summary.new_difficulty
-    sub_slot_iters: Optional[uint64] = sub_epoch_summary.new_sub_slot_iters
-    new_difficulty: Optional[uint64] = sub_epoch_summary.new_difficulty
+    sub_slot_iters = sub_epoch_summary.new_sub_slot_iters
+    new_difficulty = sub_epoch_summary.new_difficulty
     return SubEpochData(reward_chain_hash, previous_sub_epoch_overflows, sub_slot_iters, new_difficulty)
         @@@ -1558,8 -1558,8 +1558,8 @@@ def get_sp_total_iters
     assert sub_slot_data.cc_ip_vdf_info is not None
     assert sub_slot_data.total_iters is not None
     assert sub_slot_data.signage_point_index is not None
-    sp_iters: uint64 = calculate_sp_iters(constants, ssi, uint8(sub_slot_data.signage_point_index))
-    ip_iters: uint64 = uint64(sub_slot_data.cc_ip_vdf_info.number_of_iterations)
-    sp_iters: uint64 = calculate_sp_iters(constants, ssi, sub_slot_data.signage_point_index)
-    ip_iters: uint64 = sub_slot_data.cc_ip_vdf_info.number_of_iterations
+    sp_iters = calculate_sp_iters(constants, ssi, sub_slot_data.signage_point_index)
+    ip_iters = sub_slot_data.cc_ip_vdf_info.number_of_iterations
     sp_sub_slot_total_iters = uint128(sub_slot_data.total_iters - ip_iters)
     if is_overflow:
         sp_sub_slot_total_iters = uint128(sp_sub_slot_total_iters - ssi)

chia/rpc/data_layer_rpc_api.py CHANGED Viewed

         @@@ -10,22 -10,22 +10,30 @@@ from chia.data_layer.data_layer_util im
     CancelOfferResponse,
     ClearPendingRootsRequest,
     ClearPendingRootsResponse,
+    DLProof,
+    GetProofRequest,
+    GetProofResponse,
+    HashOnlyProof,
     MakeOfferRequest,
     MakeOfferResponse,
+    ProofLayer,
     Side,
+    StoreProofsHashes,
     Subscription,
     TakeOfferRequest,
     TakeOfferResponse,
     VerifyOfferResponse,
+    VerifyProofResponse,
 )
 from chia.data_layer.data_layer_wallet import DataLayerWallet, Mirror, verify_offer
 from chia.rpc.data_layer_rpc_util import marshal
 from chia.rpc.rpc_server import Endpoint, EndpointResult
+from chia.rpc.util import marshal as streamable_marshal
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.byte_types import hexstr_to_bytes
 # todo input assertions for all rpc's
-from chia.util.ints import uint64
+from chia.util.ints import uint8, uint64
 from chia.util.streamable import recurse_jsonify
 from chia.util.ws_message import WsRpcMessage
 from chia.wallet.trading.offer import Offer as TradingOffer
         @@@ -104,6 -104,6 +112,8 @@@ class DataLayerRpcApi
             "/get_sync_status": self.get_sync_status,
             "/check_plugins": self.check_plugins,
             "/clear_pending_roots": self.clear_pending_roots,
+            "/get_proof": self.get_proof,
+            "/verify_proof": self.verify_proof,
         }
     async def _state_changed(self, change: str, change_data: Optional[Dict[str, Any]]) -> List[WsRpcMessage]:
         @@@ -150,30 -150,30 +160,69 @@@
     async def get_keys(self, request: Dict[str, Any]) -> EndpointResult:
         store_id = bytes32.from_hexstr(request["id"])
         root_hash = request.get("root_hash")
+        page = request.get("page", None)
+        max_page_size = request.get("max_page_size", None)
         if root_hash is not None:
             root_hash = bytes32.from_hexstr(root_hash)
         if self.service is None:
             raise Exception("Data layer not created")
-        keys = await self.service.get_keys(store_id, root_hash)
+        if page is None:
+            keys = await self.service.get_keys(store_id, root_hash)
+        else:
+            keys_paginated = await self.service.get_keys_paginated(store_id, root_hash, page, max_page_size)
+            keys = keys_paginated.keys
         if keys == [] and root_hash is not None and root_hash != bytes32([0] * 32):
             raise Exception(f"Can't find keys for {root_hash}")
-        return {"keys": [f"0x{key.hex()}" for key in keys]}
+        response: EndpointResult = {"keys": [f"0x{key.hex()}" for key in keys]}
+        if page is not None:
+            response.update(
+                {
+                    "total_pages": keys_paginated.total_pages,
+                    "total_bytes": keys_paginated.total_bytes,
+                    "root_hash": keys_paginated.root_hash,
+                },
+            )
+        return response
     async def get_keys_values(self, request: Dict[str, Any]) -> EndpointResult:
         store_id = bytes32(hexstr_to_bytes(request["id"]))
         root_hash = request.get("root_hash")
+        page = request.get("page", None)
+        max_page_size = request.get("max_page_size", None)
         if root_hash is not None:
             root_hash = bytes32.from_hexstr(root_hash)
         if self.service is None:
             raise Exception("Data layer not created")
-        res = await self.service.get_keys_values(store_id, root_hash)
-        json_nodes = []
-        for node in res:
-            json = recurse_jsonify(dataclasses.asdict(node))
-            json_nodes.append(json)
-        if json_nodes == [] and root_hash is not None and root_hash != bytes32([0] * 32):
+        if page is None:
+            keys_values = await self.service.get_keys_values(store_id, root_hash)
+        else:
+            keys_values_paginated = await self.service.get_keys_values_paginated(
+                store_id, root_hash, page, max_page_size
+            )
+            keys_values = keys_values_paginated.keys_values
+        json_nodes = [recurse_jsonify(dataclasses.asdict(node)) for node in keys_values]
+        if not json_nodes and root_hash is not None and root_hash != bytes32([0] * 32):
             raise Exception(f"Can't find keys and values for {root_hash}")
-        return {"keys_values": json_nodes}
+        response: EndpointResult = {"keys_values": json_nodes}
+        if page is not None:
+            response.update(
+                {
+                    "total_pages": keys_values_paginated.total_pages,
+                    "total_bytes": keys_values_paginated.total_bytes,
+                    "root_hash": keys_values_paginated.root_hash,
+                },
+            )
+        return response
     async def get_ancestors(self, request: Dict[str, Any]) -> EndpointResult:
         store_id = bytes32(hexstr_to_bytes(request["id"]))
         @@@ -359,11 -359,11 +408,32 @@@
         hash_1_bytes = bytes32.from_hexstr(hash_1)
         hash_2 = request["hash_2"]
         hash_2_bytes = bytes32.from_hexstr(hash_2)
-        records = await self.service.get_kv_diff(id_bytes, hash_1_bytes, hash_2_bytes)
+        page = request.get("page", None)
+        max_page_size = request.get("max_page_size", None)
         res: List[Dict[str, Any]] = []
+        if page is None:
+            records_dict = await self.service.get_kv_diff(id_bytes, hash_1_bytes, hash_2_bytes)
+            records = list(records_dict)
+        else:
+            kv_diff_paginated = await self.service.get_kv_diff_paginated(
+                id_bytes, hash_1_bytes, hash_2_bytes, page, max_page_size
+            )
+            records = kv_diff_paginated.kv_diff
         for rec in records:
-            res.insert(0, {"type": rec.type.name, "key": rec.key.hex(), "value": rec.value.hex()})
-        return {"diff": res}
+            res.append({"type": rec.type.name, "key": rec.key.hex(), "value": rec.value.hex()})
+        response: EndpointResult = {"diff": res}
+        if page is not None:
+            response.update(
+                {
+                    "total_pages": kv_diff_paginated.total_pages,
+                    "total_bytes": kv_diff_paginated.total_bytes,
+                },
+            )
+        return response
     async def add_mirror(self, request: Dict[str, Any]) -> EndpointResult:
         store_id = request["id"]
         @@@ -458,3 -458,3 +528,44 @@@
         root = await self.service.data_store.clear_pending_roots(tree_id=request.store_id)
         return ClearPendingRootsResponse(success=root is not None, root=root)
+    @streamable_marshal
+    async def get_proof(self, request: GetProofRequest) -> GetProofResponse:
+        root = await self.service.get_root(store_id=request.store_id)
+        if root is None:
+            raise ValueError("no root")
+        all_proofs: List[HashOnlyProof] = []
+        for key in request.keys:
+            key_value = await self.service.get_value(store_id=request.store_id, key=key)
+            pi = await self.service.data_store.get_proof_of_inclusion_by_key(tree_id=request.store_id, key=key)
+            proof = HashOnlyProof.from_key_value(
+                key=key,
+                value=key_value,
+                node_hash=pi.node_hash,
+                layers=[
+                    ProofLayer(
+                        other_hash_side=uint8(layer.other_hash_side),
+                        other_hash=layer.other_hash,
+                        combined_hash=layer.combined_hash,
+                    )
+                    for layer in pi.layers
+                ],
+            )
+            all_proofs.append(proof)
+        store_proof = StoreProofsHashes(store_id=request.store_id, proofs=all_proofs)
+        return GetProofResponse(
+            proof=DLProof(
+                store_proofs=store_proof,
+                coin_id=root.coin_id,
+                inner_puzzle_hash=root.inner_puzzle_hash,
+            ),
+            success=True,
+        )
+    @streamable_marshal
+    async def verify_proof(self, request: DLProof) -> VerifyProofResponse:
+        response = await self.service.wallet_rpc.dl_verify_proof(request)
+        return response

chia/rpc/data_layer_rpc_client.py CHANGED Viewed

         @@@ -32,17 -32,17 +32,29 @@@ class DataLayerRpcClient(RpcClient)
         response = await self.fetch("batch_update", {"id": store_id.hex(), "changelist": changelist, "fee": fee})
         return response
-    async def get_keys_values(self, store_id: bytes32, root_hash: Optional[bytes32]) -> Dict[str, Any]:
+    async def get_keys_values(
+        self, store_id: bytes32, root_hash: Optional[bytes32], page: Optional[int], max_page_size: Optional[int]
+    ) -> Dict[str, Any]:
         request: Dict[str, Any] = {"id": store_id.hex()}
         if root_hash is not None:
             request["root_hash"] = root_hash.hex()
+        if page is not None:
+            request["page"] = page
+        if max_page_size is not None:
+            request["max_page_size"] = max_page_size
         response = await self.fetch("get_keys_values", request)
         return response
-    async def get_keys(self, store_id: bytes32, root_hash: Optional[bytes32]) -> Dict[str, Any]:
+    async def get_keys(
+        self, store_id: bytes32, root_hash: Optional[bytes32], page: Optional[int], max_page_size: Optional[int]
+    ) -> Dict[str, Any]:
         request: Dict[str, Any] = {"id": store_id.hex()}
         if root_hash is not None:
             request["root_hash"] = root_hash.hex()
+        if page is not None:
+            request["page"] = page
+        if max_page_size is not None:
+            request["max_page_size"] = max_page_size
         response = await self.fetch("get_keys", request)
         return response
         @@@ -87,10 -87,10 +99,15 @@@
         response = await self.fetch("add_missing_files", request)
         return response
-    async def get_kv_diff(self, store_id: bytes32, hash_1: bytes32, hash_2: bytes32) -> Dict[str, Any]:
-        response = await self.fetch(
-            "get_kv_diff", {"id": store_id.hex(), "hash_1": hash_1.hex(), "hash_2": hash_2.hex()}
-        )
+    async def get_kv_diff(
+        self, store_id: bytes32, hash_1: bytes32, hash_2: bytes32, page: Optional[int], max_page_size: Optional[int]
+    ) -> Dict[str, Any]:
+        request: Dict[str, Any] = {"id": store_id.hex(), "hash_1": hash_1.hex(), "hash_2": hash_2.hex()}
+        if page is not None:
+            request["page"] = page
+        if max_page_size is not None:
+            request["max_page_size"] = max_page_size
+        response = await self.fetch("get_kv_diff", request)
         return response
     async def get_root_history(self, store_id: bytes32) -> Dict[str, Any]:
         @@@ -131,3 -131,3 +148,12 @@@
         request = ClearPendingRootsRequest(store_id=store_id)
         response = await self.fetch("clear_pending_roots", request.marshal())
         return response
+    async def get_proof(self, store_id: bytes32, keys: List[bytes]) -> Dict[str, Any]:
+        request: Dict[str, Any] = {"store_id": store_id.hex(), "keys": [key.hex() for key in keys]}
+        response = await self.fetch("get_proof", request)
+        return response
+    async def verify_proof(self, proof: Dict[str, Any]) -> Dict[str, Any]:
+        response = await self.fetch("verify_proof", proof)
+        return response

chia/rpc/rpc_client.py CHANGED Viewed

         @@@ -31,7 -31,7 +31,7 @@@ class RpcClient
     url: str
     session: aiohttp.ClientSession
-    ssl_context: SSLContext
+    ssl_context: Optional[SSLContext]
     hostname: str
     port: uint16
     closing_task: Optional[asyncio.Task] = None
         @@@ -41,19 -41,19 +41,35 @@@
         cls: Type[_T_RpcClient],
         self_hostname: str,
         port: uint16,
-        root_path: Path,
-        net_config: Dict[str, Any],
+        root_path: Optional[Path],
+        net_config: Optional[Dict[str, Any]],
     ) -> _T_RpcClient:
-        ca_crt_path, ca_key_path = private_ssl_ca_paths(root_path, net_config)
-        crt_path = root_path / net_config["daemon_ssl"]["private_crt"]
-        key_path = root_path / net_config["daemon_ssl"]["private_key"]
-        timeout = net_config.get("rpc_timeout", 300)
+        if (root_path is not None) != (net_config is not None):
+            raise ValueError("Either both or neither of root_path and net_config must be provided")
+        ssl_context: Optional[SSLContext]
+        if root_path is None:
+            scheme = "http"
+            ssl_context = None
+        else:
+            assert root_path is not None
+            assert net_config is not None
+            scheme = "https"
+            ca_crt_path, ca_key_path = private_ssl_ca_paths(root_path, net_config)
+            crt_path = root_path / net_config["daemon_ssl"]["private_crt"]
+            key_path = root_path / net_config["daemon_ssl"]["private_key"]
+            ssl_context = ssl_context_for_client(ca_crt_path, ca_key_path, crt_path, key_path)
+        timeout = 300
+        if net_config is not None:
+            timeout = net_config.get("rpc_timeout", timeout)
         self = cls(
             hostname=self_hostname,
             port=port,
-            url=f"https://{self_hostname}:{str(port)}/",
+            url=f"{scheme}://{self_hostname}:{str(port)}/",
             session=aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=timeout)),
-            ssl_context=ssl_context_for_client(ca_crt_path, ca_key_path, crt_path, key_path),
+            ssl_context=ssl_context,
         )
         return self
         @@@ -64,8 -64,8 +80,8 @@@
         cls: Type[_T_RpcClient],
         self_hostname: str,
         port: uint16,
-        root_path: Path,
-        net_config: Dict[str, Any],
+        root_path: Optional[Path] = None,
+        net_config: Optional[Dict[str, Any]] = None,
     ) -> AsyncIterator[_T_RpcClient]:
         self = await cls.create(
             self_hostname=self_hostname,

chia/rpc/wallet_rpc_api.py CHANGED Viewed

         @@@ -11,8 -11,7 +11,9 @@@ from chia_rs import AugSchemeMPL, G1Ele
 from clvm_tools.binutils import assemble
 from chia.consensus.block_rewards import calculate_base_farmer_reward
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.data_layer.data_layer_errors import LauncherCoinNotFoundError
+from chia.data_layer.data_layer_util import dl_verify_proof
 from chia.data_layer.data_layer_wallet import DataLayerWallet
 from chia.pools.pool_wallet import PoolWallet
 from chia.pools.pool_wallet_info import FARMING_TO_POOL, PoolState, PoolWalletInfo, create_pool_state
         @@@ -285,6 -271,6 +286,7 @@@ class WalletRpcApi
             "/dl_get_mirrors": self.dl_get_mirrors,
             "/dl_new_mirror": self.dl_new_mirror,
             "/dl_delete_mirror": self.dl_delete_mirror,
+            "/dl_verify_proof": self.dl_verify_proof,
             # Verified Credential
             "/vc_mint": self.vc_mint,
             "/vc_get": self.vc_get,
         @@@ -499,14 -479,14 +501,31 @@@
             return False, False
         config: Dict[str, Any] = load_config(new_root, "config.yaml")
-        farmer_target = config["farmer"].get("xch_target_address")
-        pool_target = config["pool"].get("xch_target_address")
-        address_to_check: List[bytes32] = [decode_puzzle_hash(farmer_target), decode_puzzle_hash(pool_target)]
+        farmer_target = config["farmer"].get("xch_target_address", "")
+        pool_target = config["pool"].get("xch_target_address", "")
+        address_to_check: List[bytes32] = []
+        try:
+            farmer_decoded = decode_puzzle_hash(farmer_target)
+            address_to_check.append(farmer_decoded)
+        except ValueError:
+            farmer_decoded = None
+        try:
+            pool_decoded = decode_puzzle_hash(pool_target)
+            address_to_check.append(pool_decoded)
+        except ValueError:
+            pool_decoded = None
         found_addresses: Set[bytes32] = match_address_to_sk(sk, address_to_check, max_ph_to_search)
+        found_farmer = False
+        found_pool = False
+        if farmer_decoded is not None:
+            found_farmer = farmer_decoded in found_addresses
-        found_farmer = address_to_check[0] in found_addresses
-        found_pool = address_to_check[1] in found_addresses
+        if pool_decoded is not None:
+            found_pool = pool_decoded in found_addresses
         return found_farmer, found_pool
         @@@ -1929,9 -1920,9 +1948,7 @@@
                         "also": {
                             **info["also"],
                             "flags": ProofsChecker.from_program(
-                                uncurry_puzzle(
-                                    Program(assemble(info["also"]["proofs_checker"]))  # type: ignore[no-untyped-call]
-                                )
+                                uncurry_puzzle(Program(assemble(info["also"]["proofs_checker"])))
                             ).flags,
                         },
                     }
         @@@ -4328,6 -4386,6 +4345,19 @@@
             "transactions": [tx.to_json_dict_convenience(self.service.config) for tx in txs],
         }
+    async def dl_verify_proof(
+        self,
+        request: Dict[str, Any],
+    ) -> EndpointResult:
+        """Verify a proof of inclusion for a DL singleton"""
+        res = await dl_verify_proof(
+            request,
+            peer=self.service.get_full_node_peer(),
+            wallet_node=self.service.wallet_state_manager.wallet_node,
+        )
+        return res
     ##########################################################################################
     # Verified Credential
     ##########################################################################################

chia/rpc/wallet_rpc_client.py CHANGED Viewed

         @@@ -1,7 -1,7 +1,8 @@@
 from __future__ import annotations
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple, Union, cast
+from chia.data_layer.data_layer_util import DLProof, VerifyProofResponse
 from chia.data_layer.data_layer_wallet import Mirror, SingletonRecord
 from chia.pools.pool_wallet_info import PoolWalletInfo
 from chia.rpc.rpc_client import RpcClient
         @@@ -1245,11 -1292,30 +1246,15 @@@ class WalletRpcClient(RpcClient)
         )
         return [TransactionRecord.from_json_dict_convenience(tx) for tx in response["transactions"]]
-    async def get_notifications(
-        self, ids: Optional[List[bytes32]] = None, pagination: Optional[Tuple[Optional[int], Optional[int]]] = None
-    ) -> List[Notification]:
-        request: Dict[str, Any] = {}
-        if ids is not None:
-            request["ids"] = [id.hex() for id in ids]
-        if pagination is not None:
-            if pagination[0] is not None:
-                request["start"] = pagination[0]
-            if pagination[1] is not None:
-                request["end"] = pagination[1]
-        response = await self.fetch("get_notifications", request)
-        return [
-            Notification(
-                bytes32.from_hexstr(notification["id"]),
-                bytes.fromhex(notification["message"]),
-                uint64(notification["amount"]),
-                uint32(notification["height"]),
-            )
-            for notification in response["notifications"]
-        ]
+    async def dl_verify_proof(self, request: DLProof) -> VerifyProofResponse:
+        response = await self.fetch(path="dl_verify_proof", request_json=request.to_json_dict())
+        return VerifyProofResponse.from_json_dict(response)
+    async def get_notifications(self, request: GetNotifications) -> GetNotificationsResponse:
+        return GetNotificationsResponse.from_json_dict(await self.fetch("get_notifications", request.to_json_dict()))
     async def delete_notifications(self, ids: Optional[List[bytes32]] = None) -> bool:
-        request: Dict[str, Any] = {}
+        request = {}
         if ids is not None:
             request["ids"] = [id.hex() for id in ids]
         response = await self.fetch("delete_notifications", request)

chia/simulator/block_tools.py CHANGED Viewed

         @@@ -2057,10 -2427,8 +2057,10 @@@ def create_block_tools
     return bt
-def make_unfinished_block(block: FullBlock, constants: ConsensusConstants) -> UnfinishedBlock:
-    if is_overflow_block(constants, block.reward_chain_block.signage_point_index):
+def make_unfinished_block(
+    block: FullBlock, constants: ConsensusConstants, *, force_overflow: bool = False
+) -> UnfinishedBlock:
-    if force_overflow or is_overflow_block(constants, uint8(block.reward_chain_block.signage_point_index)):
+    if force_overflow or is_overflow_block(constants, block.reward_chain_block.signage_point_index):
         finished_ss = block.finished_sub_slots[:-1]
     else:
         finished_ss = block.finished_sub_slots

chia/types/blockchain_format/program.py CHANGED Viewed

         @@@ -1,7 -1,7 +1,7 @@@
 from __future__ import annotations
 import io
-from typing import Any, Callable, Dict, Optional, Set, Tuple
-from typing import Any, Callable, Dict, Set, Tuple
+from typing import Any, Callable, Dict, Optional, Set, Tuple, Type
 from chia_rs import ALLOW_BACKREFS, run_chia_program, tree_hash
 from clvm import SExp
         @@@ -48,6 -48,6 +48,16 @@@ class Program(SExp)
     def fromhex(cls, hexstr: str) -> Program:
         return cls.from_bytes(hexstr_to_bytes(hexstr))
+    @classmethod
+    def from_json_dict(cls: Type[Program], json_dict: Any) -> Program:
+        if isinstance(json_dict, cls):
+            return json_dict
+        item = hexstr_to_bytes(json_dict)
+        return cls.from_bytes(item)
+    def to_json_dict(self) -> str:
+        return f"0x{self}"
     def __bytes__(self) -> bytes:
         f = io.BytesIO()
         self.stream(f)  # noqa

chia/types/eligible_coin_spends.py CHANGED Viewed

         @@@ -43,114 -27,9 +43,114 @@@ class DedupCoinSpend
     cost: Optional[uint64]
+@dataclasses.dataclass(frozen=True)
+class UnspentLineageInfo:
+    coin_id: bytes32
-    coin_amount: int
+    coin_amount: uint64
+    parent_id: bytes32
-    parent_amount: int
+    parent_amount: uint64
+    parent_parent_id: bytes32
+def set_next_singleton_version(
+    current_singleton: Coin, singleton_additions: List[Coin], fast_forward_spends: Dict[bytes32, UnspentLineageInfo]
+) -> None:
+    """
+    Finds the next version of the singleton among its additions and updates the
+    fast forward spends, currently chained together, accordingly
+    Args:
+        current_singleton: the current iteration of the singleton
+        singleton_additions: the additions of the current singleton
+        fast_forward_spends: in-out parameter of the spends currently chained together
+    Raises:
+        ValueError if none of the additions are considered to be the singleton's
+        next iteration
+    """
+    singleton_child = next(
+        (addition for addition in singleton_additions if addition.puzzle_hash == current_singleton.puzzle_hash), None
+    )
+    if singleton_child is None:
+        raise ValueError("Could not find fast forward child singleton.")
+    # Keep track of this in order to chain the next ff
+    fast_forward_spends[current_singleton.puzzle_hash] = UnspentLineageInfo(
+        coin_id=singleton_child.name(),
+        coin_amount=singleton_child.amount,
+        parent_id=singleton_child.parent_coin_info,
+        parent_amount=current_singleton.amount,
+        parent_parent_id=current_singleton.parent_coin_info,
+    )
+def perform_the_fast_forward(
+    unspent_lineage_info: UnspentLineageInfo,
+    spend_data: BundleCoinSpend,
+    fast_forward_spends: Dict[bytes32, UnspentLineageInfo],
+) -> Tuple[CoinSpend, List[Coin]]:
+    """
+    Performs a singleton fast forward, including the updating of all previous
+    additions to point to the most recent version, and updates the fast forward
+    spends, currently chained together, accordingly
+    Args:
+        unspent_lineage_info: the singleton's most recent lineage information
+        spend_data: the current spend's data
+        fast_forward_spends: in-out parameter of the spends currently chained together
+    Returns:
+        CoinSpend: the new coin spend after performing the fast forward
+        List[Coin]: the updated additions that point to the new coin to spend
+    Raises:
+        ValueError if none of the additions are considered to be the singleton's
+        next iteration
+    """
+    new_coin = Coin(
+        unspent_lineage_info.parent_id, spend_data.coin_spend.coin.puzzle_hash, unspent_lineage_info.coin_amount
+    )
+    new_parent = Coin(
+        unspent_lineage_info.parent_parent_id,
+        spend_data.coin_spend.coin.puzzle_hash,
+        unspent_lineage_info.parent_amount,
+    )
+    # These hold because puzzle hash is not expected to change
+    assert new_coin.name() == unspent_lineage_info.coin_id
+    assert new_parent.name() == unspent_lineage_info.parent_id
+    rust_coin_spend = RustCoinSpend(
+        coin=spend_data.coin_spend.coin,
+        puzzle_reveal=RustProgram.from_bytes(bytes(spend_data.coin_spend.puzzle_reveal)),
+        solution=RustProgram.from_bytes(bytes(spend_data.coin_spend.solution)),
+    )
+    new_solution = SerializedProgram.from_bytes(
+        fast_forward_singleton(spend=rust_coin_spend, new_coin=new_coin, new_parent=new_parent)
+    )
+    singleton_child = None
+    patched_additions = []
+    for addition in spend_data.additions:
+        patched_addition = Coin(unspent_lineage_info.coin_id, addition.puzzle_hash, addition.amount)
+        patched_additions.append(patched_addition)
+        if addition.puzzle_hash == spend_data.coin_spend.coin.puzzle_hash:
+            # We found the next version of this singleton
+            singleton_child = patched_addition
+    if singleton_child is None:
+        raise ValueError("Could not find fast forward child singleton.")
+    new_coin_spend = CoinSpend(new_coin, spend_data.coin_spend.puzzle_reveal, new_solution)
+    # Keep track of this in order to chain the next ff
+    fast_forward_spends[spend_data.coin_spend.coin.puzzle_hash] = UnspentLineageInfo(
+        coin_id=singleton_child.name(),
+        coin_amount=singleton_child.amount,
+        parent_id=singleton_child.parent_coin_info,
+        parent_amount=unspent_lineage_info.coin_amount,
+        parent_parent_id=unspent_lineage_info.parent_id,
+    )
+    return new_coin_spend, patched_additions
 @dataclasses.dataclass(frozen=True)
 class EligibleCoinSpends:
-    eligible_spends: Dict[bytes32, DedupCoinSpend] = dataclasses.field(default_factory=dict)
+    deduplication_spends: Dict[bytes32, DedupCoinSpend] = dataclasses.field(default_factory=dict)
+    fast_forward_spends: Dict[bytes32, UnspentLineageInfo] = dataclasses.field(default_factory=dict)
     def get_deduplication_info(
         self, *, bundle_coin_spends: Dict[bytes32, BundleCoinSpend], max_cost: int

chia/types/spend_bundle_conditions.py CHANGED Viewed

         @@@ -1,5 -1,5 +1,7 @@@
 from __future__ import annotations
-from chia_rs import ELIGIBLE_FOR_DEDUP, Spend, SpendBundleConditions
+import chia_rs
-__all__ = ["Spend", "SpendBundleConditions", "ELIGIBLE_FOR_DEDUP"]
+ELIGIBLE_FOR_DEDUP = chia_rs.ELIGIBLE_FOR_DEDUP
+Spend = chia_rs.Spend
+SpendBundleConditions = chia_rs.SpendBundleConditions

chia/util/condition_tools.py CHANGED Viewed

         @@@ -80,7 -80,7 +80,7 @@@ def make_aggsig_final_message
     if isinstance(spend, Coin):
         coin = spend
     elif isinstance(spend, Spend):
-        coin = Coin(spend.parent_id, spend.puzzle_hash, spend.coin_amount)
+        coin = Coin(spend.parent_id, spend.puzzle_hash, uint64(spend.coin_amount))
     else:
         raise ValueError(f"Expected Coin or Spend, got {type(spend)}")  # pragma: no cover

chia/util/generator_tools.py CHANGED Viewed

         @@@ -51,7 -48,7 +51,7 @@@ def additions_for_npc(npc_result: NPCRe
         return []
     for spend in npc_result.conds.spends:
         for puzzle_hash, amount, _ in spend.create_coin:
-            coin = Coin(spend.coin_id, puzzle_hash, amount)
+            coin = Coin(spend.coin_id, puzzle_hash, uint64(amount))
             additions.append(coin)
     return additions

chia/util/initial-config.yaml CHANGED Viewed

         @@@ -687,8 -650,8 +687,6 @@@ data_layer
   logging: *logging
-  # TODO: which of these are really appropriate?
   ssl:
     private_crt: "config/ssl/data_layer/private_data_layer.crt"
     private_key: "config/ssl/data_layer/private_data_layer.key"

chia/util/misc.py CHANGED Viewed

         @@@ -8,6 -7,6 +8,7 @@@ import o
 import signal
 import sys
 from dataclasses import dataclass
+from inspect import getframeinfo, stack
 from pathlib import Path
 from types import FrameType
 from typing import (
         @@@ -19,16 -17,15 +20,21 @@@
     ContextManager,
     Dict,
     Generic,
+    Iterable,
     Iterator,
     List,
     Optional,
     Sequence,
+    Tuple,
+    Type,
     TypeVar,
     Union,
     final,
+    get_args,
+    get_origin,
 )
+import psutil
 from typing_extensions import Protocol
 from chia.util.errors import InvalidPathError
         @@@ -388,36 -374,3 +394,83 @@@ async def split_async_manager(manager:
         yield split
     finally:
         await split.exit(if_needed=True)
+class ValuedEventSentinel:
+    pass
+@dataclasses.dataclass
+class ValuedEvent(Generic[T]):
+    _value_sentinel: ClassVar[ValuedEventSentinel] = ValuedEventSentinel()
+    _event: asyncio.Event = dataclasses.field(default_factory=asyncio.Event)
+    _value: Union[ValuedEventSentinel, T] = _value_sentinel
+    def set(self, value: T) -> None:
+        if not isinstance(self._value, ValuedEventSentinel):
+            raise Exception("Value already set")
+        self._value = value
+        self._event.set()
+    async def wait(self) -> T:
+        await self._event.wait()
+        if isinstance(self._value, ValuedEventSentinel):
+            raise Exception("Value not set despite event being set")
+        return self._value
+def available_logical_cores() -> int:
+    if sys.platform == "darwin":
+        count = os.cpu_count()
+        assert count is not None
+        return count
+    return len(psutil.Process().cpu_affinity())
+def caller_file_and_line(distance: int = 1, relative_to: Iterable[Path] = ()) -> Tuple[str, int]:
+    caller = getframeinfo(stack()[distance + 1][0])
+    caller_path = Path(caller.filename)
+    options: List[str] = [caller_path.as_posix()]
+    for path in relative_to:
+        try:
+            options.append(caller_path.relative_to(path).as_posix())
+        except ValueError:
+            pass
+    return min(options, key=len), caller.lineno
+def satisfies_hint(obj: T, type_hint: Type[T]) -> bool:
+    """
+    Check if an object satisfies a type hint.
+    This is a simplified version of `isinstance` that also handles generic types.
+    """
+    # Start from the initial type hint
+    object_hint_pairs = [(obj, type_hint)]
+    while len(object_hint_pairs) > 0:
+        obj, type_hint = object_hint_pairs.pop()
+        origin = get_origin(type_hint)
+        args = get_args(type_hint)
+        if origin:
+            # Handle generic types
+            if not isinstance(obj, origin):
+                return False
+            if len(args) > 0:
+                # Tuple[T, ...] gets handled just like List[T]
+                if origin is list or (origin is tuple and args[-1] is Ellipsis):
+                    object_hint_pairs.extend((item, args[0]) for item in obj)
+                elif origin is tuple:
+                    object_hint_pairs.extend((item, arg) for item, arg in zip(obj, args))
+                elif origin is dict:
+                    object_hint_pairs.extend((k, args[0]) for k in obj.keys())
+                    object_hint_pairs.extend((v, args[1]) for v in obj.values())
+                else:
+                    raise NotImplementedError(f"Type {origin} is not yet supported")
+        else:
+            # Handle concrete types
+            if type(obj) is not type_hint:
+                return False
+    return True

chia/util/streamable.py CHANGED Viewed

         @@@ -81,11 -81,11 +81,6 @@@ class ConversionError(StreamableError)
         )
-unhashable_types = [
-    "Program",
-    "SerializedProgram",
-]
 _T_Streamable = TypeVar("_T_Streamable", bound="Streamable")
 ParseFunctionType = Callable[[BinaryIO], object]
         @@@ -183,20 -183,20 +178,6 @@@ def convert_byte_type(f_type: Type[Any]
         raise ConversionError(item, f_type, e) from e
-def convert_unhashable_type(f_type: Type[Any], item: Any) -> Any:
-    if isinstance(item, f_type):
-        return item
-    if not isinstance(item, bytes):
-        item = convert_hex_string(item)
-    try:
-        if hasattr(f_type, "from_bytes_unchecked"):
-            return f_type.from_bytes_unchecked(item)
-        else:
-            return f_type.from_bytes(item)
-    except Exception as e:
-        raise ConversionError(item, f_type, e) from e
 def convert_primitive(f_type: Type[Any], item: Any) -> Any:
     if isinstance(item, f_type):
         return item
         @@@ -242,9 -242,9 +223,6 @@@ def function_to_convert_one_item(f_type
         convert_inner_func = function_to_convert_one_item(inner_type)
         # Ignoring for now as the proper solution isn't obvious
         return lambda items: convert_list(convert_inner_func, items)  # type: ignore[arg-type]
-    elif f_type.__name__ in unhashable_types:
-        # Type is unhashable (bls type), so cast from hex string
-        return lambda item: convert_unhashable_type(f_type, item)
     elif hasattr(f_type, "from_json_dict"):
         return lambda item: f_type.from_json_dict(item)
     elif issubclass(f_type, bytes):
         @@@ -292,13 -292,10 +270,12 @@@ def function_to_post_init_process_one_i
 def recurse_jsonify(d: Any) -> Any:
     """
-    Makes bytes objects and unhashable types into strings with 0x, and makes large ints into
-    strings.
+    Makes bytes objects into strings with 0x, and makes large ints into strings.
     """
-    if dataclasses.is_dataclass(d):
+    if hasattr(d, "override_json_serialization"):
+        overrid_ret: Union[List[Any], Dict[str, Any], str, None, int] = d.override_json_serialization(recurse_jsonify)
+        return overrid_ret
+    elif dataclasses.is_dataclass(d):
         new_dict = {}
         for field in dataclasses.fields(d):
             new_dict[field.name] = recurse_jsonify(getattr(d, field.name))
         @@@ -316,7 -313,7 +293,7 @@@
             new_dict[name] = recurse_jsonify(val)
         return new_dict
-    elif type(d).__name__ in unhashable_types or issubclass(type(d), bytes):
+    elif issubclass(type(d), bytes):
         return f"0x{bytes(d).hex()}"
     elif isinstance(d, Enum):
         return d.name

chia/wallet/cat_wallet/dao_cat_wallet.py CHANGED Viewed

         @@@ -291,7 -292,7 +291,7 @@@ class DAOCATWallet
                 primaries = [
                     Payment(
                         new_innerpuzzle.get_tree_hash(),
-                        uint64(vote_amount),
+                        vote_amount,
                         [standard_inner_puz.get_tree_hash()],
                     )
                 ]
         @@@ -301,12 -302,12 +301,12 @@@
                     conditions=(CreatePuzzleAnnouncement(message),),
                 )
             else:
-                vote_amount = amount - running_sum
+                vote_amount = uint64(amount - running_sum)
                 running_sum = running_sum + coin.amount
                 primaries = [
                     Payment(
                         new_innerpuzzle.get_tree_hash(),
-                        uint64(vote_amount),
+                        vote_amount,
                         [standard_inner_puz.get_tree_hash()],
                     ),
                 ]

chia/wallet/dao_wallet/dao_wallet.py CHANGED Viewed

         @@@ -646,7 -642,7 +646,7 @@@ class DAOWallet
         genesis_launcher_puz = SINGLETON_LAUNCHER
         # launcher coin contains singleton launcher, launcher coin ID == singleton_id == treasury_id
-        launcher_coin = Coin(origin.name(), genesis_launcher_puz.get_tree_hash(), 1)
+        launcher_coin = Coin(origin.name(), genesis_launcher_puz.get_tree_hash(), uint64(1))
         if cat_tail_hash is None:
             assert amount_of_cats_to_create is not None

chia/wallet/db_wallet/db_wallet_puzzles.py CHANGED Viewed

         @@@ -3,6 -3,6 +3,7 @@@ from __future__ import annotation
 from typing import Iterator, List, Tuple, Union
 from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.util.ints import uint64
         @@@ -39,7 -39,7 +40,7 @@@ def create_host_layer_puzzle(innerpuz:
     )
-def match_dl_singleton(puzzle: Program) -> Tuple[bool, Iterator[Program]]:
+def match_dl_singleton(puzzle: Union[Program, SerializedProgram]) -> Tuple[bool, Iterator[Program]]:
     """
     Given a puzzle test if it's a CAT and, if it is, return the curried arguments
     """

chia/wallet/did_wallet/did_wallet.py CHANGED Viewed

         @@@ -1365,17 -1403,17 +1365,20 @@@ class DIDWallet
         return True
     async def update_metadata(self, metadata: Dict[str, str]) -> bool:
-        did_info: DIDInfo = DIDInfo(
-            self.did_info.origin_coin,
-            self.did_info.backup_ids,
-            self.did_info.num_of_backup_ids_needed,
-            self.did_info.parent_info,
-            self.did_info.current_inner,
-            self.did_info.temp_coin,
-            self.did_info.temp_puzhash,
-            self.did_info.temp_pubkey,
-            self.did_info.sent_recovery_transaction,
-            json.dumps(metadata),
+        # validate metadata
+        if not all(isinstance(k, str) and isinstance(v, str) for k, v in metadata.items()):
+            raise ValueError("Metadata key value pairs must be strings.")
+        did_info = DIDInfo(
+            origin_coin=self.did_info.origin_coin,
+            backup_ids=self.did_info.backup_ids,
+            num_of_backup_ids_needed=self.did_info.num_of_backup_ids_needed,
+            parent_info=self.did_info.parent_info,
+            current_inner=self.did_info.current_inner,
+            temp_coin=self.did_info.temp_coin,
+            temp_puzhash=self.did_info.temp_puzhash,
+            temp_pubkey=self.did_info.temp_pubkey,
+            sent_recovery_transaction=self.did_info.sent_recovery_transaction,
+            metadata=json.dumps(metadata),
         )
         await self.save_info(did_info)
         await self.wallet_state_manager.update_wallet_puzzle_hashes(self.wallet_info.id)

chia/wallet/key_val_store.py CHANGED Viewed

         @@@ -18,9 -18,9 +18,9 @@@ class KeyValStore
         self.db_wrapper = db_wrapper
         async with self.db_wrapper.writer_maybe_transaction() as conn:
             await conn.execute("CREATE TABLE IF NOT EXISTS key_val_store(key text PRIMARY KEY, value blob)")
-            await conn.execute("CREATE INDEX IF NOT EXISTS key_val_name on key_val_store(key)")
+            # Remove an old redundant index on the primary key
+            # See https://github.com/Chia-Network/chia-blockchain/issues/10276
+            await conn.execute("DROP INDEX IF EXISTS key_val_name")
         return self
     async def get_object(self, key: str, object_type: Any) -> Any:

chia/wallet/puzzle_drivers.py CHANGED Viewed

         @@@ -104,7 -104,7 +104,7 @@@ def decode_info_value(cls: Any, value:
     else:
         if value == "()":  # special case
             return Program.to([])
-        expression: SExp = assemble(value)  # type: ignore
+        expression: SExp = assemble(value)
         if expression.atom is None:
             return Program(expression)
         else:

chia/wallet/puzzles/clawback/drivers.py CHANGED Viewed

         @@@ -6,8 -6,8 +6,9 @@@ from typing import Any, List, Optional
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.types.coin_spend import CoinSpend
+from chia.types.coin_spend import CoinSpend, make_spend
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.util.condition_tools import conditions_for_solution
 from chia.util.ints import uint64
         @@@ -121,17 -121,17 +122,15 @@@ def create_merkle_solution
 def match_clawback_puzzle(
-    uncurried: UncurriedPuzzle, inner_puzzle: Program, inner_solution: Program
+    uncurried: UncurriedPuzzle,
+    inner_puzzle: Union[Program, SerializedProgram],
+    inner_solution: Union[Program, SerializedProgram],
 ) -> Optional[ClawbackMetadata]:
     # Check if the inner puzzle is a P2 puzzle
     if MOD != uncurried.mod:
         return None
     # Fetch Remark condition
-    conditions = conditions_for_solution(
-        inner_puzzle,
-        inner_solution,
-        DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM // 8,
-    )
+    conditions = conditions_for_solution(inner_puzzle, inner_solution, DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM // 8)
     metadata: Optional[ClawbackMetadata] = None
     new_puzhash: Set[bytes32] = set()
     if conditions is not None:

chia/wallet/puzzles/prefarm/make_prefarm_ph.py CHANGED Viewed

         @@@ -29,7 -29,7 +29,7 @@@ def make_puzzle(amount: int) -> int
     # print(puzzle)
     # TODO: properly type hint clvm_tools
-    assembled_puzzle = binutils.assemble(puzzle)  # type: ignore[no-untyped-call]
+    assembled_puzzle = binutils.assemble(puzzle)
     puzzle_prog = Program.to(assembled_puzzle)
     print("Program: ", puzzle_prog)
     puzzle_hash = puzzle_prog.get_tree_hash()

chia/wallet/puzzles/prefarm/spend_prefarm.py CHANGED Viewed

         @@@ -52,15 -51,11 +52,11 @@@ async def main() -> None
         ph1 = decode_puzzle_hash(address1)
         ph2 = decode_puzzle_hash(address2)
-        p_farmer_2 = Program.to(
-            binutils.assemble(f"(q . ((51 0x{ph1.hex()} {farmer_amounts}) (51 0x{ph2.hex()} {farmer_amounts})))")
+        p_farmer_2 = SerializedProgram.to(
-            binutils.assemble(
-                f"(q . ((51 0x{ph1.hex()} {farmer_amounts}) " f"(51 0x{ph2.hex()} {farmer_amounts})))"
-            )  # type: ignore[no-untyped-call]
+            binutils.assemble(f"(q . ((51 0x{ph1.hex()} {farmer_amounts}) " f"(51 0x{ph2.hex()} {farmer_amounts})))")
         )
-        p_pool_2 = Program.to(
-            binutils.assemble(f"(q . ((51 0x{ph1.hex()} {pool_amounts}) (51 0x{ph2.hex()} {pool_amounts})))")
+        p_pool_2 = SerializedProgram.to(
-            binutils.assemble(
-                f"(q . ((51 0x{ph1.hex()} {pool_amounts}) " f"(51 0x{ph2.hex()} {pool_amounts})))"
-            )  # type: ignore[no-untyped-call]
+            binutils.assemble(f"(q . ((51 0x{ph1.hex()} {pool_amounts}) " f"(51 0x{ph2.hex()} {pool_amounts})))")
         )
         print(f"Ph1: {ph1.hex()}")
         @@@ -68,7 -63,7 +64,7 @@@
         assert ph1.hex() == "1b7ab2079fa635554ad9bd4812c622e46ee3b1875a7813afba127bb0cc9794f9"
         assert ph2.hex() == "6f184a7074c925ef8688ce56941eb8929be320265f824ec7e351356cc745d38a"
-        p_solution = SerializedProgram.to(binutils.assemble("()"))  # type: ignore[no-untyped-call]
-        p_solution = Program.to(binutils.assemble("()"))
+        p_solution = SerializedProgram.to(binutils.assemble("()"))
         sb_farmer = SpendBundle([CoinSpend(farmer_prefarm, p_farmer_2, p_solution)], G2Element())
         sb_pool = SpendBundle([CoinSpend(pool_prefarm, p_pool_2, p_solution)], G2Element())

chia/wallet/trading/trade_store.py CHANGED Viewed

         @@@ -152,7 -153,7 +152,8 @@@ class TradeStore
             await conn.execute("CREATE INDEX IF NOT EXISTS trade_confirmed_index on trade_records(confirmed_at_index)")
             await conn.execute("CREATE INDEX IF NOT EXISTS trade_status on trade_records(status)")
-            await conn.execute("CREATE INDEX IF NOT EXISTS trade_id on trade_records(trade_id)")
+            # Remove an old redundant index on the primary key
+            await conn.execute("DROP INDEX IF EXISTS trade_id")
             if needs_is_my_offer_migration:
                 await migrate_is_my_offer(self.log, conn)

chia/wallet/util/wallet_sync_utils.py CHANGED Viewed

         @@@ -33,10 -33,10 +33,10 @@@ from chia.protocols.wallet_protocol imp
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.coin import Coin, hash_coin_ids
 from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.types.coin_spend import CoinSpend
+from chia.types.coin_spend import CoinSpend, make_spend
 from chia.types.header_block import HeaderBlock
 from chia.util.ints import uint32
-from chia.util.merkle_set import MerkleSet, confirm_included_already_hashed, confirm_not_included_already_hashed
+from chia.util.merkle_set import confirm_included_already_hashed, confirm_not_included_already_hashed
 from chia.wallet.util.peer_request_cache import PeerRequestCache
 log = logging.getLogger(__name__)
         @@@ -151,12 -151,12 +151,8 @@@ def validate_removals
         # we must find the ones relevant to our wallets.
         # Verify removals root
-        removals_merkle_set = MerkleSet()
-        for name_coin in coins:
-            _, coin = name_coin
-            if coin is not None:
-                removals_merkle_set.add_already_hashed(coin.name())
-        removals_root = removals_merkle_set.get_root()
+        removals_items = [name for name, coin in coins if coin is not None]
+        removals_root = bytes32(compute_merkle_set_root(removals_items))
         if root != removals_root:
             return False
     else:
         @@@ -202,7 -202,7 +198,6 @@@ async def request_and_validate_removals
     )
     if removals_res is None or isinstance(removals_res, RejectRemovalsRequest):
         return False
-    assert removals_res.proofs is not None
     return validate_removals(removals_res.coins, removals_res.proofs, removals_root)

chia/wallet/wallet_blockchain.py CHANGED Viewed

         @@@ -99,8 -99,8 +99,8 @@@ class WalletBlockchain(BlockchainInterf
             and block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters is not None
         ):
             assert block.finished_sub_slots[0].challenge_chain.new_difficulty is not None  # They both change together
-            sub_slot_iters = uint64(block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters)
-            difficulty = uint64(block.finished_sub_slots[0].challenge_chain.new_difficulty)
-            sub_slot_iters: uint64 = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters
-            difficulty: uint64 = block.finished_sub_slots[0].challenge_chain.new_difficulty
+            sub_slot_iters = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters
+            difficulty = block.finished_sub_slots[0].challenge_chain.new_difficulty
         else:
             sub_slot_iters = self._sub_slot_iters
             difficulty = self._difficulty

chia/wallet/wallet_puzzle_store.py CHANGED Viewed

         @@@ -49,16 -49,16 +49,17 @@@ class WalletPuzzleStore
             await conn.execute(
                 "CREATE INDEX IF NOT EXISTS derivation_index_index on derivation_paths(derivation_index)"
             )
-            await conn.execute("CREATE INDEX IF NOT EXISTS ph on derivation_paths(puzzle_hash)")
             await conn.execute("CREATE INDEX IF NOT EXISTS pubkey on derivation_paths(pubkey)")
+            await conn.execute("CREATE INDEX IF NOT EXISTS ph on derivation_paths(puzzle_hash)")
             await conn.execute("CREATE INDEX IF NOT EXISTS wallet_type on derivation_paths(wallet_type)")
+            # Remove an old, misnamed, redundant index on `wallet_type`
+            # See https://github.com/Chia-Network/chia-blockchain/issues/10276
+            await conn.execute("DROP INDEX IF EXISTS used")
             await conn.execute("CREATE INDEX IF NOT EXISTS derivation_paths_wallet_id on derivation_paths(wallet_id)")
-            await conn.execute("CREATE INDEX IF NOT EXISTS used on derivation_paths(wallet_type)")
+            await conn.execute("CREATE INDEX IF NOT EXISTS derivation_paths_used_index on derivation_paths(used)")
+            await conn.execute(
+                "CREATE INDEX IF NOT EXISTS derivation_paths_hardened_index on derivation_paths(hardened)"
+            )
         # the lock is locked by the users of this class
         self.lock = asyncio.Lock()
         @@@ -245,26 -245,26 +246,6 @@@
         return None
-    async def index_for_puzzle_hash_and_wallet(self, puzzle_hash: bytes32, wallet_id: uint32) -> Optional[uint32]:
-        """
-        Returns the derivation path for the puzzle_hash.
-        Returns None if not present.
-        """
-        async with self.db_wrapper.reader_no_transaction() as conn:
-            row = await execute_fetchone(
-                conn,
-                "SELECT derivation_index FROM derivation_paths WHERE puzzle_hash=? AND wallet_id=?;",
-                (
-                    puzzle_hash.hex(),
-                    wallet_id,
-                ),
-            )
-        if row is not None:
-            return uint32(row[0])
-        return None
     async def get_wallet_identifier_for_puzzle_hash(self, puzzle_hash: bytes32) -> Optional[WalletIdentifier]:
         """
         Returns the derivation path for the puzzle_hash.

chia/wallet/wallet_transaction_store.py CHANGED Viewed

         @@@ -65,22 -65,22 +65,20 @@@ class WalletTransactionStore
             await conn.execute(
                 "CREATE INDEX IF NOT EXISTS tx_confirmed_index on transaction_record(confirmed_at_height)"
             )
             await conn.execute("CREATE INDEX IF NOT EXISTS tx_created_index on transaction_record(created_at_time)")
+            # Remove a redundant index on `created_at_time`
+            # See https://github.com/Chia-Network/chia-blockchain/issues/10276
+            await conn.execute("DROP INDEX IF EXISTS tx_created_time")
+            await conn.execute("CREATE INDEX IF NOT EXISTS tx_to_puzzle_hash on transaction_record(to_puzzle_hash)")
             await conn.execute("CREATE INDEX IF NOT EXISTS tx_confirmed on transaction_record(confirmed)")
             await conn.execute("CREATE INDEX IF NOT EXISTS tx_sent on transaction_record(sent)")
-            await conn.execute("CREATE INDEX IF NOT EXISTS tx_created_time on transaction_record(created_at_time)")
-            await conn.execute("CREATE INDEX IF NOT EXISTS tx_type on transaction_record(type)")
-            await conn.execute("CREATE INDEX IF NOT EXISTS tx_to_puzzle_hash on transaction_record(to_puzzle_hash)")
             await conn.execute(
                 "CREATE INDEX IF NOT EXISTS transaction_record_wallet_id on transaction_record(wallet_id)"
             )
+            await conn.execute(
+                "CREATE INDEX IF NOT EXISTS transaction_record_trade_id_idx ON transaction_record(trade_id)"
+            )
+            await conn.execute("CREATE INDEX IF NOT EXISTS tx_type on transaction_record(type)")
             try:
                 await conn.execute("CREATE TABLE tx_times(txid blob PRIMARY KEY, valid_times blob)")
         @@@ -102,19 -102,19 +100,28 @@@
         Store TransactionRecord in DB and Cache.
         """
         async with self.db_wrapper.writer_maybe_transaction() as conn:
+            transaction_record_old = TransactionRecordOld(
+                confirmed_at_height=record.confirmed_at_height,
+                created_at_time=record.created_at_time,
+                to_puzzle_hash=record.to_puzzle_hash,
+                amount=record.amount,
+                fee_amount=record.fee_amount,
+                confirmed=record.confirmed,
+                sent=record.sent,
+                spend_bundle=record.spend_bundle,
+                additions=record.additions,
+                removals=record.removals,
+                wallet_id=record.wallet_id,
+                sent_to=record.sent_to,
+                trade_id=record.trade_id,
+                type=record.type,
+                name=record.name,
+                memos=record.memos,
+            )
             await conn.execute_insert(
                 "INSERT OR REPLACE INTO transaction_record VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
                 (
-                    bytes(
-                        TransactionRecordOld(
-                            spend_bundle=record.spend_bundle,
-                            **{
-                                k: v
-                                for k, v in dataclasses.asdict(record).items()
-                                if k not in ("valid_times", "spend_bundle")
-                            },
-                        )
-                    ),
+                    bytes(transaction_record_old),
                     record.name,
                     record.confirmed_at_height,
                     record.created_at_time,
         @@@ -129,11 -129,11 +136,7 @@@
                 ),
             )
             await conn.execute_insert(
-                "INSERT OR REPLACE INTO tx_times " "(txid, valid_times) " "VALUES(?, ?)",
-                (
-                    record.name,
-                    bytes(record.valid_times),
-                ),
+                "INSERT OR REPLACE INTO tx_times VALUES (?, ?)", (record.name, bytes(record.valid_times))
             )
     async def delete_transaction_record(self, tx_id: bytes32) -> None:
         @@@ -426,27 -426,27 +429,42 @@@
             ).close()
     async def _get_new_tx_records_from_old(self, old_records: List[TransactionRecordOld]) -> List[TransactionRecord]:
+        tx_id_to_valid_times: Dict[bytes, ConditionValidTimes] = {}
+        empty_valid_times = ConditionValidTimes()
         async with self.db_wrapper.reader_no_transaction() as conn:
-            valid_times: Dict[bytes32, ConditionValidTimes] = {}
             chunked_records: List[List[TransactionRecordOld]] = [
                 old_records[i : min(len(old_records), i + self.db_wrapper.host_parameter_limit)]
                 for i in range(0, len(old_records), self.db_wrapper.host_parameter_limit)
             ]
             for records_chunk in chunked_records:
                 cursor = await conn.execute(
-                    f"SELECT txid, valid_times from tx_times WHERE txid IN ({','.join('?' *  len(records_chunk))})",
+                    f"SELECT txid, valid_times from tx_times WHERE txid IN ({','.join('?' * len(records_chunk))})",
                     tuple(tx.name for tx in records_chunk),
                 )
-                valid_times = {
-                    **valid_times,
-                    **{bytes32(res[0]): ConditionValidTimes.from_bytes(res[1]) for res in await cursor.fetchall()},
-                }
+                for row in await cursor.fetchall():
+                    tx_id_to_valid_times[row[0]] = ConditionValidTimes.from_bytes(row[1])
                 await cursor.close()
         return [
             TransactionRecord(
-                valid_times=valid_times[record.name] if record.name in valid_times else ConditionValidTimes(),
+                confirmed_at_height=record.confirmed_at_height,
+                created_at_time=record.created_at_time,
+                to_puzzle_hash=record.to_puzzle_hash,
+                amount=record.amount,
+                fee_amount=record.fee_amount,
+                confirmed=record.confirmed,
+                sent=record.sent,
                 spend_bundle=record.spend_bundle,
-                **{k: v for k, v in dataclasses.asdict(record).items() if k != "spend_bundle"},
+                additions=record.additions,
+                removals=record.removals,
+                wallet_id=record.wallet_id,
+                sent_to=record.sent_to,
+                trade_id=record.trade_id,
+                type=record.type,
+                name=record.name,
+                memos=record.memos,
+                valid_times=(
+                    tx_id_to_valid_times[record.name] if record.name in tx_id_to_valid_times else empty_valid_times
+                ),
             )
             for record in old_records
         ]

install.sh CHANGED Viewed

         @@@ -5,12 -5,12 +5,12 @@@ set -o errexi
 USAGE_TEXT="\
 Usage: $0 [-adilpsh]
-  -a                          automated install, no questions
+  -a                          ignored for compatibility with earlier versions
   -d                          install development dependencies
   -i                          install non-editable
   -l                          install legacy keyring dependencies (linux only)
   -p                          additional plotters installation
-  -s                          skip python package installation and just do pip install
+  -s                          ignored for compatibility with earlier versions
   -h                          display this help and exit
 "
         @@@ -18,9 -18,9 +18,7 @@@ usage()
   echo "${USAGE_TEXT}"
 }
-PACMAN_AUTOMATED=
 EXTRAS=
-SKIP_PACKAGE_INSTALL=
 PLOTTER_INSTALL=
 EDITABLE='-e'
         @@@ -28,7 -28,7 +26,7 @@@ while getopts adilpsh fla
 do
   case "${flag}" in
     # automated
-    a) PACMAN_AUTOMATED=--noconfirm;;
+    a) :;;
     # development
     d) EXTRAS=${EXTRAS}dev,;;
     # non-editable
         @@@ -37,26 -37,26 +35,12 @@@
     l) EXTRAS=${EXTRAS}legacy_keyring,;;
     p) PLOTTER_INSTALL=1;;
     # simple install
-    s) SKIP_PACKAGE_INSTALL=1;;
+    s) :;;
     h) usage; exit 0;;
     *) echo; usage; exit 1;;
   esac
 done
-UBUNTU=false
-DEBIAN=false
-if [ "$(uname)" = "Linux" ]; then
-  #LINUX=1
-  if command -v apt-get >/dev/null; then
-    OS_ID=$(lsb_release -is)
-    if [ "$OS_ID" = "Debian" ]; then
-      DEBIAN=true
-    else
-      UBUNTU=true
-    fi
-  fi
-fi
 # Check for non 64 bit ARM64/Raspberry Pi installs
 if [ "$(uname -m)" = "armv7l" ]; then
   echo ""
         @@@ -70,65 -70,65 +54,6 @@@ f
 # Get submodules
 git submodule update --init mozilla-ca
-UBUNTU_PRE_20=0
-UBUNTU_20=0
-if $UBUNTU; then
-  LSB_RELEASE=$(lsb_release -rs)
-  # In case Ubuntu minimal does not come with bc
-  if ! command -v bc > /dev/null 2>&1; then
-    sudo apt install bc -y
-  fi
-  # Mint 20.04 responds with 20 here so 20 instead of 20.04
-  if [ "$(echo "$LSB_RELEASE<20" | bc)" = "1" ]; then
-    UBUNTU_PRE_20=1
-  else
-    UBUNTU_20=1
-  fi
-fi
-install_python3_and_sqlite3_from_source_with_yum() {
-  CURRENT_WD=$(pwd)
-  TMP_PATH=/tmp
-  # Preparing installing Python
-  echo 'yum groupinstall -y "Development Tools"'
-  sudo yum groupinstall -y "Development Tools"
-  echo "sudo yum install -y openssl-devel openssl libffi-devel bzip2-devel wget"
-  sudo yum install -y openssl-devel openssl libffi-devel bzip2-devel wget
-  echo "cd $TMP_PATH"
-  cd "$TMP_PATH"
-  # Install sqlite>=3.37
-  # yum install sqlite-devel brings sqlite3.7 which is not compatible with chia
-  echo "wget https://www.sqlite.org/2022/sqlite-autoconf-3370200.tar.gz"
-  wget https://www.sqlite.org/2022/sqlite-autoconf-3370200.tar.gz
-  tar xf sqlite-autoconf-3370200.tar.gz
-  echo "cd sqlite-autoconf-3370200"
-  cd sqlite-autoconf-3370200
-  echo "./configure --prefix=/usr/local"
-  # '| stdbuf ...' seems weird but this makes command outputs stay in single line.
-  ./configure --prefix=/usr/local | stdbuf -o0 cut -b1-"$(tput cols)" | sed -u 'i\\o033[2K' | stdbuf -o0 tr '\n' '\r'; echo
-  echo "make -j$(nproc)"
-  make -j"$(nproc)" | stdbuf -o0 cut -b1-"$(tput cols)" | sed -u 'i\\o033[2K' | stdbuf -o0 tr '\n' '\r'; echo
-  echo "sudo make install"
-  sudo make install | stdbuf -o0 cut -b1-"$(tput cols)" | sed -u 'i\\o033[2K' | stdbuf -o0 tr '\n' '\r'; echo
-  # yum install python3 brings Python3.6 which is not supported by chia
-  cd ..
-  echo "wget https://www.python.org/ftp/python/3.9.11/Python-3.9.11.tgz"
-  wget https://www.python.org/ftp/python/3.9.11/Python-3.9.11.tgz
-  tar xf Python-3.9.11.tgz
-  echo "cd Python-3.9.11"
-  cd Python-3.9.11
-  echo "LD_RUN_PATH=/usr/local/lib ./configure --prefix=/usr/local"
-  # '| stdbuf ...' seems weird but this makes command outputs stay in single line.
-  LD_RUN_PATH=/usr/local/lib ./configure --prefix=/usr/local | stdbuf -o0 cut -b1-"$(tput cols)" | sed -u 'i\\o033[2K' | stdbuf -o0 tr '\n' '\r'; echo
-  echo "LD_RUN_PATH=/usr/local/lib make -j$(nproc)"
-  LD_RUN_PATH=/usr/local/lib make -j"$(nproc)" | stdbuf -o0 cut -b1-"$(tput cols)" | sed -u 'i\\o033[2K' | stdbuf -o0 tr '\n' '\r'; echo
-  echo "LD_RUN_PATH=/usr/local/lib sudo make altinstall"
-  LD_RUN_PATH=/usr/local/lib sudo make altinstall | stdbuf -o0 cut -b1-"$(tput cols)" | sed -u 'i\\o033[2K' | stdbuf -o0 tr '\n' '\r'; echo
-  cd "$CURRENT_WD"
-}
 # You can specify preferred python version by exporting `INSTALL_PYTHON_VERSION`
 # e.g. `export INSTALL_PYTHON_VERSION=3.8`
         @@@ -183,75 -183,73 +108,6 @@@ find_openssl()
   set -e
 }
-# Manage npm and other install requirements on an OS specific basis
-if [ "$SKIP_PACKAGE_INSTALL" = "1" ]; then
-  echo "Skipping system package installation"
-elif [ "$(uname)" = "Linux" ]; then
-  #LINUX=1
-  if [ "$UBUNTU_PRE_20" = "1" ]; then
-    # Ubuntu
-    echo "Installing on Ubuntu pre 20.*."
-    sudo apt-get update
-    # distutils must be installed as well to avoid a complaint about ensurepip while
-    # creating the venv.  This may be related to a mis-check while using or
-    # misconfiguration of the secondary Python version 3.7.  The primary is Python 3.6.
-    sudo apt-get install -y python3.7-venv python3.7-distutils openssl
-  elif [ "$UBUNTU_20" = "1" ]; then
-    echo "Installing on Ubuntu 20.* or newer."
-    sudo apt-get update
-    sudo apt-get install -y python3-venv openssl
-  elif [ "$DEBIAN" = "true" ]; then
-    echo "Installing on Debian."
-    sudo apt-get update
-    sudo apt-get install -y python3-venv openssl
-  elif type pacman >/dev/null 2>&1 && [ -f "/etc/arch-release" ]; then
-    # Arch Linux
-    # Arch provides latest python version. User will need to manually install python 3.9 if it is not present
-    echo "Installing on Arch Linux."
-    case $(uname -m) in
-      x86_64|aarch64)
-        if ! pacman -Qs "^git$" > /dev/null || ! pacman -Qs "^openssl$" > /dev/null ; then
-          sudo pacman ${PACMAN_AUTOMATED} -S --needed git openssl
-        fi
-        sudo pacman ${PACMAN_AUTOMATED} -S --needed git openssl
-        ;;
-      *)
-        echo "Incompatible CPU architecture. Must be x86_64 or aarch64."
-        exit 1
-        ;;
-    esac
-  elif type yum >/dev/null 2>&1 && [ ! -f "/etc/redhat-release" ] && [ ! -f "/etc/centos-release" ] && [ ! -f "/etc/fedora-release" ]; then
-    # AMZN 2
-    echo "Installing on Amazon Linux 2."
-    if ! command -v python3.9 >/dev/null 2>&1; then
-      install_python3_and_sqlite3_from_source_with_yum
-    fi
-  elif type yum >/dev/null 2>&1 && [ -f "/etc/centos-release" ]; then
-    # CentOS
-    echo "Install on CentOS."
-    if ! command -v python3.9 >/dev/null 2>&1; then
-      install_python3_and_sqlite3_from_source_with_yum
-    fi
-  elif type yum >/dev/null 2>&1 && [ -f "/etc/redhat-release" ] && grep Rocky /etc/redhat-release; then
-    echo "Installing on Rocky."
-    # TODO: make this smarter about getting the latest version
-    sudo yum install --assumeyes python39 openssl
-  elif type yum >/dev/null 2>&1 && [ -f "/etc/redhat-release" ] || [ -f "/etc/fedora-release" ]; then
-    # Redhat or Fedora
-    echo "Installing on Redhat/Fedora."
-    if ! command -v python3.9 >/dev/null 2>&1; then
-      sudo yum install -y python39 openssl
-    fi
-  fi
-elif [ "$(uname)" = "Darwin" ]; then
-  echo "Installing on macOS."
-  if ! type brew >/dev/null 2>&1; then
-    echo "Installation currently requires brew on macOS - https://brew.sh/"
-    exit 1
-  fi
-  echo "Installing OpenSSL"
-  brew install openssl
-fi
 if [ "$(uname)" = "OpenBSD" ]; then
   export MAKE=${MAKE:-gmake}
   export BUILD_VDF_CLIENT=${BUILD_VDF_CLIENT:-N}
         @@@ -277,11 -275,11 +133,13 @@@ if ! command -v "$INSTALL_PYTHON_PATH"
 fi
 if [ "$PYTHON_MAJOR_VER" -ne "3" ] || [ "$PYTHON_MINOR_VER" -lt "7" ] || [ "$PYTHON_MINOR_VER" -ge "12" ]; then
-  echo "Chia requires Python version >= 3.7 and  < 3.12.0" >&2
+  echo "Chia requires Python version >= 3.8 and  < 3.12.0" >&2
   echo "Current Python version = $INSTALL_PYTHON_VERSION" >&2
   # If Arch, direct to Arch Wiki
   if type pacman >/dev/null 2>&1 && [ -f "/etc/arch-release" ]; then
     echo "Please see https://wiki.archlinux.org/title/python#Old_versions for support." >&2
+  else
+    echo "Please install python per your OS instructions." >&2
   fi
   exit 1
         @@@ -292,6 -290,6 +150,7 @@@ find_sqlit
 echo "SQLite version for Python is ${SQLITE_VERSION}"
 if [ "$SQLITE_MAJOR_VER" -lt "3" ] || [ "$SQLITE_MAJOR_VER" = "3" ] && [ "$SQLITE_MINOR_VER" -lt "8" ]; then
   echo "Only sqlite>=3.8 is supported"
+  echo "Please install sqlite3 per your OS instructions."
   exit 1
 fi
         @@@ -302,6 -300,6 +161,7 @@@ echo "OpenSSL version for Python is ${O
 if [ "$OPENSSL_VERSION_INT" -lt "269488367" ]; then
   echo "WARNING: OpenSSL versions before 3.0.2, 1.1.1n, or 1.0.2zd are vulnerable to CVE-2022-0778"
   echo "Your OS may have patched OpenSSL and not updated the version to 1.1.1n"
+  echo "We recommend updating to the latest version of OpenSSL available for your OS"
 fi
 # If version of `python` and "$INSTALL_PYTHON_VERSION" does not match, clear old version

mypy-exclusions.txt CHANGED Viewed

         @@@ -74,7 -83,7 +74,6 @@@ tests.core.test_daemon_rp
 tests.core.test_db_conversion
 tests.core.test_filter
 tests.core.test_full_node_rpc
-tests.core.test_merkle_set
 tests.core.util.test_cached_bls
 tests.core.util.test_config
 tests.core.util.test_file_keyring_synchronization

setup.py CHANGED Viewed

         @@@ -7,24 -7,24 +7,24 @@@ from setuptools import find_packages, s
 dependencies = [
     "aiofiles==23.2.1",  # Async IO for files
-    "anyio==4.0.0",
-    "boto3==1.29.0",  # AWS S3 for DL s3 plugin
-    "chiavdf==1.1.0",  # timelord and vdf verification
+    "anyio==4.2.0",
-    "boto3==1.34.25",  # AWS S3 for DL s3 plugin
+    "boto3==1.34.40",  # AWS S3 for DL s3 plugin
+    "chiavdf==1.1.1",  # timelord and vdf verification
     "chiabip158==1.3",  # bip158-style wallet filters
     "chiapos==2.0.3",  # proof of space
     "clvm==0.9.8",
-    "clvm_tools==0.4.7",  # Currying, Program.to, other conveniences
-    "chia_rs==0.4.0",
-    "chia_rs==0.2.13",
-    "clvm-tools-rs==0.1.38",  # Rust implementation of clvm_tools' compiler
-    "aiohttp==3.8.6",  # HTTP server for full node rpc
+    "clvm_tools==0.4.8",  # Currying, Program.to, other conveniences
+    "chia_rs==0.5.2",
+    "clvm-tools-rs==0.1.40",  # Rust implementation of clvm_tools' compiler
+    "aiohttp==3.9.1",  # HTTP server for full node rpc
     "aiosqlite==0.19.0",  # asyncio wrapper for sqlite, to store blocks
-    "bitstring==4.1.2",  # Binary data management library
+    "bitstring==4.1.4",  # Binary data management library
     "colorama==0.4.6",  # Colorizes terminal output
-    "colorlog==6.7.0",  # Adds color to logs
-    "concurrent-log-handler==0.9.24",  # Concurrently log and rotate logs
-    "cryptography==41.0.5",  # Python cryptography library for TLS - keyring conflict
+    "colorlog==6.8.2",  # Adds color to logs
+    "concurrent-log-handler==0.9.25",  # Concurrently log and rotate logs
+    "cryptography==42.0.2",  # Python cryptography library for TLS - keyring conflict
     "filelock==3.13.1",  # For reading and writing config multiprocess and multithread safely  (non-reentrant locks)
-    "keyring==23.13.1",  # Store keys in MacOS Keychain, Windows Credential Locker
+    "keyring==24.3.0",  # Store keys in MacOS Keychain, Windows Credential Locker
     "PyYAML==6.0.1",  # Used for config file format
     "setproctitle==1.3.3",  # Gives the chia processes readable names
     "sortedcontainers==2.4.0",  # For maintaining sorted mempools
         @@@ -46,29 -44,28 +46,29 @@@ upnp_dependencies =
 dev_dependencies = [
     "build==1.0.3",
-    "coverage==7.3.2",
+    "coverage==7.4.1",
     "diff-cover==8.0.1",
-    "pre-commit==3.5.0",
-    "py3createtorrent==1.1.0",
-    "pylint==3.0.2",
-    "pytest==7.4.3",
+    "pre-commit==3.5.0; python_version < '3.9'",
+    "pre-commit==3.6.0; python_version >= '3.9'",
+    "py3createtorrent==1.2.0",
+    "pylint==3.0.3",
+    "pytest==8.0.0",
     "pytest-cov==4.1.0",
     "pytest-mock==3.12.0",
-    "pytest-xdist==3.4.0",
+    "pytest-xdist==3.5.0",
     "pyupgrade==3.15.0",
-    "twine==4.0.2",
-    "isort==5.12.0",
-    "flake8==6.1.0",
-    "mypy==1.7.0",
-    "black==23.11.0",
-    "lxml==4.9.3",
+    "twine==5.0.0",
+    "isort==5.13.2",
+    "flake8==7.0.0",
+    "mypy==1.8.0",
+    "black==23.12.1",
+    "lxml==5.1.0",
     "aiohttp_cors==0.7.0",  # For blackd
-    "pyinstaller==5.13.0",
-    "types-aiofiles==23.2.0.0",
+    "pyinstaller==6.3.0",
+    "types-aiofiles==23.2.0.20240106",
     "types-cryptography==3.3.23.2",
     "types-pyyaml==6.0.12.12",
-    "types-setuptools==68.2.0.1",
+    "types-setuptools==69.0.0.20240115",
 ]
 legacy_keyring_dependencies = [

tests/clvm/test_spend_sim.py CHANGED Viewed

         @@@ -6,7 -6,7 +6,8 @@@ from chia_rs import G2Elemen
 from chia.clvm.spend_sim import sim_and_client
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.types.coin_spend import make_spend
-from chia.types.coin_spend import CoinSpend
+from chia.types.coin_spend import compute_additions, make_spend
+from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.spend_bundle import SpendBundle
         @@@ -45,6 -45,6 +46,54 @@@ async def test_all_endpoints()
         for i in range(0, 5):
             await sim.farm_block()
+        # get_coin_records_by_hint
+        acs = Program.to(1)
+        acs_ph = acs.get_tree_hash()
+        await sim.farm_block(acs_ph)
+        coin_records = await sim_client.get_coin_records_by_puzzle_hash(acs.get_tree_hash())
+        coin = coin_records[0].coin
+        hint = Program.to("hint").get_tree_hash()
+        non_existent_hint = Program.to("non_existent_hint").get_tree_hash()
+        acs_hint_spent = make_spend(
+            coin,
+            acs,
+            Program.to([[ConditionOpcode.CREATE_COIN, acs.get_tree_hash(), 2, [hint]]]),
+        )
+        hinted_coin = compute_additions(acs_hint_spent)[0]
+        acs_hint_unspent = make_spend(
+            hinted_coin,
+            acs,
+            Program.to([[ConditionOpcode.CREATE_COIN, acs.get_tree_hash(), 1, [hint]]]),
+        )
+        await sim_client.push_tx(SpendBundle([acs_hint_spent, acs_hint_unspent], G2Element()))
+        await sim.farm_block(acs_ph)
+        coin_records = await sim_client.get_coin_records_by_hint(hint, include_spent_coins=False)
+        assert len(coin_records) == 1
+        coin_records = await sim_client.get_coin_records_by_hint(hint, include_spent_coins=True)
+        assert len(coin_records) == 2
+        coin_records = await sim_client.get_coin_records_by_hint(non_existent_hint)
+        assert len(coin_records) == 0
+        coin_records = await sim_client.get_coin_records_by_puzzle_hash(acs.get_tree_hash())
+        next_coin = coin_records[-1].coin
+        height = sim.get_height()
+        acs_hint_next_coin = make_spend(
+            next_coin,
+            acs,
+            Program.to([[ConditionOpcode.CREATE_COIN, acs.get_tree_hash(), 2, [hint]]]),
+        )
+        await sim_client.push_tx(SpendBundle([acs_hint_next_coin], G2Element()))
+        await sim.farm_block(acs_ph)
+        coin_records = await sim_client.get_coin_records_by_hint(hint, start_height=height + 1, end_height=height + 2)
+        assert len(coin_records) == 1
+        coin_records = await sim_client.get_coin_records_by_hint(hint, start_height=height)
+        assert len(coin_records) == 3
+        coin_records = await sim_client.get_coin_records_by_hint(hint, end_height=height + 1)
+        assert len(coin_records) == 2
+        coin_records = await sim_client.get_coin_records_by_hint(hint, end_height=height + 1, include_spent_coins=False)
+        assert len(coin_records) == 1
+        coin_records = await sim_client.get_coin_records_by_hint(hint, start_height=height + 3)
+        assert len(coin_records) == 0
         # get_coin_records_by_puzzle_hash
         coin_records = await sim_client.get_coin_records_by_puzzle_hash(bytes32([0] * 32))
         coin_record_name = coin_records[0].coin.name()
         @@@ -89,7 -89,7 +138,7 @@@
         # push_tx
         puzzle_hash = bytes.fromhex("9dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2")  # Program.to(1)
         await sim.farm_block(puzzle_hash)
-        spendable_coin = await sim_client.get_coin_records_by_puzzle_hash(puzzle_hash)
+        spendable_coin = await sim_client.get_coin_records_by_puzzle_hash(puzzle_hash, include_spent_coins=False)
         spendable_coin = spendable_coin[0].coin
         bundle = SpendBundle(
             [
         @@@ -102,7 -102,7 +151,7 @@@
             G2Element(),
         )
         result, error = await sim_client.push_tx(bundle)
+        assert not error
         # get_all_mempool_tx_ids
         mempool_items = await sim_client.get_all_mempool_tx_ids()
         assert len(mempool_items) == 1

tests/cmds/cmd_test_utils.py ADDED Viewed

         @@@ -377,6 -377,6 +377,7 @@@ def create_service_and_wallet_client_ge
         rpc_port: Optional[int] = None,
         root_path: Optional[Path] = None,
         consume_errors: bool = True,
+        use_ssl: bool = True,
     ) -> AsyncIterator[Tuple[_T_RpcClient, Dict[str, Any]]]:
         if root_path is None:
             root_path = default_root

tests/cmds/test_cmds_util.py RENAMED Viewed

         @@@ -1,0 -1,0 +1,27 @@@
+from __future__ import annotations
+from pathlib import Path
+import pytest
+from chia.cmds.cmds_util import get_any_service_client
+from chia.rpc.rpc_client import RpcClient
+from tests.util.misc import RecordingWebServer
+@pytest.mark.anyio
+async def test_get_any_service_client_works_without_ssl(
+    root_path_populated_with_config: Path,
+    recording_web_server: RecordingWebServer,
+) -> None:
+    expected_result = {"success": True, "keepy": "uppy"}
+    async with get_any_service_client(
+        client_type=RpcClient,
+        rpc_port=recording_web_server.web_server.listen_port,
+        root_path=root_path_populated_with_config,
+        use_ssl=False,
+    ) as [rpc_client, _]:
+        result = await rpc_client.fetch(path="", request_json={"response": expected_result})
+    assert result == expected_result

tests/cmds/wallet/test_wallet.py CHANGED Viewed

         @@@ -3,7 -3,6 +3,8 @@@ from __future__ import annotation
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union, cast
+import pkg_resources
+import pytest
 from chia_rs import Coin, G2Element
 from chia.server.outbound_message import NodeType
         @@@ -627,6 -626,6 +628,59 @@@ def test_add_token(capsys: object, get_
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
+def test_make_offer_bad_filename(
+    capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path], tmp_path: Path
+) -> None:
+    _, root_dir = get_test_cli_clients
+    request_cat_id = get_bytes32(2)
+    request_nft_id = get_bytes32(2)
+    request_nft_addr = encode_puzzle_hash(request_nft_id, "nft")
+    # we offer xch and a random cat via wallet id and request a random cat, nft via coin and tail
+    command_args_dir = [
+        "wallet",
+        "make_offer",
+        FINGERPRINT_ARG,
+        f"-p{str(tmp_path)}",
+        "--reuse",
+        "-m1",
+        "--offer",
+        "1:10",
+        "--offer",
+        "3:100",
+        "--request",
+        f"{request_cat_id.hex()}:10",
+        "--request",
+        f"{request_nft_addr}:1",
+    ]
+    test_file: Path = tmp_path / "test.offer"
+    test_file.touch(mode=0o400)
+    command_args_unwritable = [
+        "wallet",
+        "make_offer",
+        FINGERPRINT_ARG,
+        f"-p{str(test_file)}",
+        "--reuse",
+        "-m1",
+        "--offer",
+        "1:10",
+        "--offer",
+        "3:100",
+        "--request",
+        f"{request_cat_id.hex()}:10",
+        "--request",
+        f"{request_nft_addr}:1",
+    ]
+    with pytest.raises(AssertionError, match=r".*Invalid value for '-p' / '--filepath.*is a directory.*"):
+        run_cli_command_and_assert(capsys, root_dir, command_args_dir, [""])
+    with pytest.raises(AssertionError, match=r".*Invalid value for '-p' / '--filepath.*is not writable.*"):
+        run_cli_command_and_assert(capsys, root_dir, command_args_unwritable, [""])
 def test_make_offer(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path], tmp_path: Path) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients

tests/conftest.py CHANGED Viewed

         @@@ -5,6 -5,6 +5,7 @@@ import asynci
 import dataclasses
 import datetime
 import functools
+import json
 import math
 import multiprocessing
 import os
         @@@ -20,11 -19,18 +21,13 @@@ import pytes
 # TODO: update after resolution in https://github.com/pytest-dev/pytest/issues/7469
 from _pytest.fixtures import SubRequest
+from pytest import MonkeyPatch
+import tests
 from chia.clvm.spend_sim import CostLogger
-# Set spawn after stdlib imports, but before other imports
 from chia.consensus.constants import ConsensusConstants
-from chia.farmer.farmer import Farmer
-from chia.farmer.farmer_api import FarmerAPI
 from chia.full_node.full_node import FullNode
 from chia.full_node.full_node_api import FullNodeAPI
-from chia.harvester.harvester import Harvester
-from chia.harvester.harvester_api import HarvesterAPI
-from chia.protocols import full_node_protocol
 from chia.rpc.farmer_rpc_client import FarmerRpcClient
 from chia.rpc.harvester_rpc_client import HarvesterRpcClient
 from chia.rpc.wallet_rpc_client import WalletRpcClient
         @@@ -66,37 -61,20 +69,52 @@@ from chia.util.task_timing import main
 from chia.util.task_timing import start_task_instrumentation, stop_task_instrumentation
 from chia.wallet.wallet_node import WalletNode
 from chia.wallet.wallet_node_api import WalletNodeAPI
+from tests import ether
 from tests.core.data_layer.util import ChiaRoot
 from tests.core.node_height import node_height_at_least
 from tests.simulation.test_simulation import test_constants_modified
-from tests.util.misc import BenchmarkRunner, GcMode, RecordingWebServer, _AssertRuntime, measure_overhead
-from tests.util.misc import BenchmarkRunner, GcMode, _AssertRuntime, measure_overhead
+from tests.util.misc import BenchmarkRunner, GcMode, RecordingWebServer, TestId, _AssertRuntime, measure_overhead
+from tests.util.setup_nodes import (
+    OldSimulatorsAndWallets,
+    SimulatorsAndWallets,
+    setup_full_system,
+    setup_n_nodes,
+    setup_simulators_and_wallets,
+    setup_simulators_and_wallets_service,
+    setup_two_nodes,
+)
 from tests.util.time_out_assert import time_out_assert
 multiprocessing.set_start_method("spawn")
 from pathlib import Path
-from chia.simulator.block_tools import BlockTools, create_block_tools, create_block_tools_async, test_constants
+from chia.simulator.block_tools import BlockTools, create_block_tools_async, test_constants
 from chia.simulator.keyring import TempKeyring
-from chia.simulator.setup_nodes import setup_farmer_multi_harvester
 from chia.util.keyring_wrapper import KeyringWrapper
+from tests.util.setup_nodes import setup_farmer_multi_harvester
+@pytest.fixture(name="ether_setup", autouse=True)
+def ether_setup_fixture(request: SubRequest, record_property: Callable[[str, object], None]) -> Iterator[None]:
+    with MonkeyPatch.context() as monkeypatch_context:
+        monkeypatch_context.setattr(ether, "record_property", record_property)
+        monkeypatch_context.setattr(ether, "test_id", TestId.create(node=request.node))
+        yield
+@pytest.fixture(autouse=True)
+def ether_test_id_property_fixture(ether_setup: None, record_property: Callable[[str, object], None]) -> None:
+    assert ether.test_id is not None, "ether.test_id is None, did you forget to use the ether_setup fixture?"
+    record_property("test_id", json.dumps(ether.test_id.marshal(), ensure_ascii=True, sort_keys=True))
+def make_old_setup_simulators_and_wallets(new: SimulatorsAndWallets) -> OldSimulatorsAndWallets:
+    return (
+        [simulator.peer_api for simulator in new.simulators],
+        [(wallet.node, wallet.peer_server) for wallet in new.wallets],
+        new.bt,
+    )
 @pytest.fixture(scope="session")
         @@@ -131,16 -109,16 +149,12 @@@ def benchmark_runner_overhead_fixture(
 @pytest.fixture(name="benchmark_runner")
 def benchmark_runner_fixture(
-    request: SubRequest,
     benchmark_runner_overhead: float,
-    record_property: Callable[[str, object], None],
     benchmark_repeat: int,
 ) -> BenchmarkRunner:
-    label = request.node.name
     return BenchmarkRunner(
-        label=label,
+        test_id=ether.test_id,
         overhead=benchmark_runner_overhead,
-        record_property=record_property,
     )
         @@@ -434,6 -418,6 +448,13 @@@ def pytest_addoption(parser: pytest.Par
         type=int,
         help=f"The number of times to run each benchmark, default {default_repeats}.",
     )
+    group.addoption(
+        "--time-out-assert-repeats",
+        action="store",
+        default=default_repeats,
+        type=int,
+        help=f"The number of times to run each test with time out asserts, default {default_repeats}.",
+    )
 def pytest_configure(config):
         @@@ -459,6 -443,6 +480,22 @@@
     globals()[benchmark_repeat_fixture.__name__] = benchmark_repeat_fixture
+    time_out_assert_repeats = config.getoption("--time-out-assert-repeats")
+    if time_out_assert_repeats != 1:
+        @pytest.fixture(
+            name="time_out_assert_repeat",
+            autouse=True,
+            params=[
+                pytest.param(repeat, id=f"time_out_assert_repeat{repeat:03d}")
+                for repeat in range(time_out_assert_repeats)
+            ],
+        )
+        def time_out_assert_repeat_fixture(request: SubRequest) -> int:
+            return request.param
+        globals()[time_out_assert_repeat_fixture.__name__] = time_out_assert_repeat_fixture
 def pytest_collection_modifyitems(session, config: pytest.Config, items: List[pytest.Function]):
     # https://github.com/pytest-dev/pytest/issues/3730#issuecomment-567142496

tests/core/consensus/test_block_creation.py CHANGED Viewed

         @@@ -1,56 -1,0 +1,56 @@@
+from __future__ import annotations
+from typing import List
+import pytest
+from chia.consensus.block_creation import compute_block_cost, compute_block_fee
+from chia.consensus.condition_costs import ConditionCost
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.util.ints import uint32
+from chia.util.ints import uint32, uint64
+from tests.core.make_block_generator import make_block_generator
+@pytest.mark.parametrize("add_amount", [[0], [1, 2, 3], []])
+@pytest.mark.parametrize("rem_amount", [[0], [1, 2, 3], []])
+def test_compute_block_fee(add_amount: List[int], rem_amount: List[int]) -> None:
-    additions: List[Coin] = [Coin(bytes32.random(), bytes32.random(), amt) for amt in add_amount]
-    removals: List[Coin] = [Coin(bytes32.random(), bytes32.random(), amt) for amt in rem_amount]
+    additions: List[Coin] = [Coin(bytes32.random(), bytes32.random(), uint64(amt)) for amt in add_amount]
+    removals: List[Coin] = [Coin(bytes32.random(), bytes32.random(), uint64(amt)) for amt in rem_amount]
+    # the fee is the left-overs from the removals (spent) coins after deducting
+    # the newly created coins (additions)
+    expected = sum(rem_amount) - sum(add_amount)
+    if expected < 0:
+        with pytest.raises(ValueError, match="does not fit into uint64"):
+            compute_block_fee(additions, removals)
+    else:
+        assert compute_block_fee(additions, removals) == expected
+def test_compute_block_cost(softfork_height: uint32) -> None:
+    num_coins = 10
+    generator = make_block_generator(num_coins)
+    cost = int(compute_block_cost(generator, DEFAULT_CONSTANTS, softfork_height))
+    coin_cost = ConditionCost.CREATE_COIN.value * num_coins
+    agg_sig_cost = ConditionCost.AGG_SIG.value * num_coins
+    cost -= coin_cost
+    cost -= agg_sig_cost
+    cost -= len(bytes(generator.program)) * DEFAULT_CONSTANTS.COST_PER_BYTE
+    print(f"{cost=}")
+    # the cost is a non-trivial combination of the CLVM cost of running the puzzles
+    # and before the hard-fork, combined with the cost of running the generator ROM
+    # Consensus requires these costs to be unchanged over time, so this test
+    # ensures compatibility
+    if softfork_height >= DEFAULT_CONSTANTS.HARD_FORK_HEIGHT:
+        expected = 180980
+    else:
+        expected = 3936699
+    assert cost == expected

tests/core/custom_types/test_coin.py CHANGED Viewed

         @@@ -78,32 -78,32 +78,32 @@@ def test_construction() -> None
     with pytest.raises(OverflowError, match="int too big to convert"):
         # overflow
-        Coin(H1, H2, 0x10000000000000000)
+        Coin(H1, H2, 0x10000000000000000)  # type: ignore[arg-type]
     with pytest.raises(OverflowError, match="can't convert negative int to unsigned"):
         # overflow
-        Coin(H1, H2, -1)
+        Coin(H1, H2, -1)  # type: ignore[arg-type]
     H1_short = b"a" * 31
     H1_long = b"a" * 33
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="could not convert slice to array"):
         # short hash
-        Coin(H1_short, H2, 1)
+        Coin(H1_short, H2, uint64(1))
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="could not convert slice to array"):
         # long hash
-        Coin(H1_long, H2, 1)
+        Coin(H1_long, H2, uint64(1))
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="could not convert slice to array"):
         # short hash
-        Coin(H2, H1_short, 1)
+        Coin(H2, H1_short, uint64(1))
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match="could not convert slice to array"):
         # long hash
-        Coin(H2, H1_long, 1)
+        Coin(H2, H1_long, uint64(1))
-    c = Coin(H1, H2, 1000)
+    c = Coin(H1, H2, uint64(1000))
     assert c.parent_coin_info == H1
     assert c.puzzle_hash == H2
     assert c.amount == 1000

tests/core/custom_types/test_spend_bundle.py CHANGED Viewed

         @@@ -14,6 -15,6 +14,7 @@@ from chia.types.coin_spend import CoinS
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.spend_bundle import SpendBundle
 from chia.util.errors import ValidationError
+from chia.util.ints import uint64
 BLANK_SPEND_BUNDLE = SpendBundle(coin_spends=[], aggregated_signature=G2Element())
 NULL_SIGNATURE = "0xc" + "0" * 191
         @@@ -59,10 -104,10 +60,10 @@@ def create_spends(num: int) -> Tuple[Li
     for i in range(num):
         target_ph = rand_hash(rng)
         conditions = [[ConditionOpcode.CREATE_COIN, target_ph, 1]]
-        coin = Coin(rand_hash(rng), puzzle_hash, 1000)
-        new_coin = Coin(coin.name(), target_ph, 1)
+        coin = Coin(rand_hash(rng), puzzle_hash, uint64(1000))
+        new_coin = Coin(coin.name(), target_ph, uint64(1))
         create_coin.append(new_coin)
-        spends.append(CoinSpend(coin, puzzle, Program.to(conditions)))
+        spends.append(make_spend(coin, puzzle, Program.to(conditions)))
     return spends, create_coin

tests/core/data_layer/test_data_rpc.py CHANGED Viewed

         @@@ -9,6 -9,6 +9,7 @@@ import o
 import random
 import sys
 import time
+from copy import deepcopy
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, AsyncIterator, Dict, List, Optional, Tuple, cast
         @@@ -16,11 -16,12 +17,27 @@@
 import anyio
 import pytest
-from chia.cmds.data_funcs import clear_pending_roots, wallet_log_in_cmd
+from chia.cmds.data_funcs import (
+    clear_pending_roots,
+    get_keys_cmd,
+    get_keys_values_cmd,
+    get_kv_diff_cmd,
+    get_proof_cmd,
+    verify_proof_cmd,
+    wallet_log_in_cmd,
+)
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.data_layer.data_layer import DataLayer
-from chia.data_layer.data_layer_api import DataLayerAPI
-from chia.data_layer.data_layer_errors import OfferIntegrityError
-from chia.data_layer.data_layer_util import OfferStore, Status, StoreProofs
+from chia.data_layer.data_layer_errors import KeyNotFoundError, OfferIntegrityError
+from chia.data_layer.data_layer_util import (
+    HashOnlyProof,
+    OfferStore,
+    ProofLayer,
+    Status,
+    StoreProofs,
+    key_hash,
+    leaf_hash,
+)
 from chia.data_layer.data_layer_wallet import DataLayerWallet, verify_offer
 from chia.data_layer.download_data import get_delta_filename, get_full_tree_filename
 from chia.rpc.data_layer_rpc_api import DataLayerRpcApi
         @@@ -35,7 -37,7 +52,8 @@@ from chia.types.blockchain_format.sized
 from chia.types.peer_info import PeerInfo
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.config import save_config
-from chia.util.ints import uint16, uint32, uint64
+from chia.util.hash import std_hash
+from chia.util.ints import uint8, uint16, uint32, uint64
 from chia.util.keychain import bytes_to_mnemonic
 from chia.util.timing import adjusted_timeout, backoff_times
 from chia.wallet.trading.offer import Offer as TradingOffer
         @@@ -425,6 -398,6 +443,11 @@@ async def test_keys_values_ancestors
         assert len(pairs_before["keys_values"]) == len(keys_before["keys"]) == 5
         assert len(pairs_after["keys_values"]) == len(keys_after["keys"]) == 7
+        with pytest.raises(Exception, match="Can't find keys"):
+            await data_rpc_api.get_keys({"id": store_id.hex(), "root_hash": bytes32([0] * 31 + [1]).hex()})
+        with pytest.raises(Exception, match="Can't find keys and values"):
+            await data_rpc_api.get_keys_values({"id": store_id.hex(), "root_hash": bytes32([0] * 31 + [1]).hex()})
 @pytest.mark.anyio
 async def test_get_roots(
         @@@ -759,6 -723,6 +782,7 @@@ class StoreSetup
     id: bytes32
     original_hash: bytes32
     data_layer: DataLayer
+    data_rpc_client: DataLayerRpcClient
 @dataclass(frozen=True)
         @@@ -792,12 -756,12 +816,20 @@@ async def offer_setup_fixture
         for wallet_service in wallet_services:
             assert wallet_service.rpc_server is not None
             port = wallet_service.rpc_server.listen_port
-            data_layer = await exit_stack.enter_async_context(
-                init_data_layer(
+            data_layer_service = await exit_stack.enter_async_context(
+                init_data_layer_service(
                     wallet_rpc_port=port, wallet_service=wallet_service, bt=bt, db_path=tmp_path.joinpath(str(port))
                 )
             )
+            data_layer = data_layer_service._api.data_layer
             data_rpc_api = DataLayerRpcApi(data_layer)
+            assert data_layer_service.rpc_server is not None
+            data_rpc_client = await DataLayerRpcClient.create(
+                self_hostname,
+                port=data_layer_service.rpc_server.listen_port,
+                root_path=bt.root_path,
+                net_config=bt.config,
+            )
             create_response = await data_rpc_api.create_data_store({"verbose": True})
             await full_node_api.process_transaction_records(records=create_response["txs"], timeout=60)
         @@@ -808,6 -772,6 +840,7 @@@
                     id=bytes32.from_hexstr(create_response["id"]),
                     original_hash=bytes32([0] * 32),
                     data_layer=data_layer,
+                    data_rpc_client=data_rpc_client,
                 )
             )
         @@@ -847,16 -811,16 +880,23 @@@
                 id=maker.id,
                 original_hash=maker_original_root_hash,
                 data_layer=maker.data_layer,
+                data_rpc_client=maker.data_rpc_client,
             ),
             taker=StoreSetup(
                 api=taker.api,
                 id=taker.id,
                 original_hash=taker_original_root_hash,
                 data_layer=taker.data_layer,
+                data_rpc_client=taker.data_rpc_client,
             ),
             full_node_api=full_node_api,
         )
+        maker.data_rpc_client.close()
+        await maker.data_rpc_client.await_closed()
+        taker.data_rpc_client.close()
+        await taker.data_rpc_client.await_closed()
 async def populate_offer_setup(offer_setup: OfferSetup, count: int) -> OfferSetup:
     if count > 0:
         @@@ -906,12 -870,12 +946,14 @@@
             id=offer_setup.maker.id,
             original_hash=maker_original_root_hash,
             data_layer=offer_setup.maker.data_layer,
+            data_rpc_client=offer_setup.maker.data_rpc_client,
         ),
         taker=StoreSetup(
             api=offer_setup.taker.api,
             id=offer_setup.taker.id,
             original_hash=taker_original_root_hash,
             data_layer=offer_setup.taker.data_layer,
+            data_rpc_client=offer_setup.taker.data_rpc_client,
         ),
         full_node_api=offer_setup.full_node_api,
     )
         @@@ -2292,39 -2252,3 +2334,823 @@@ async def test_wallet_log_in_changes_ac
         active_fingerprint = cast(int, (await wallet_rpc_api.get_logged_in_fingerprint(request={}))["fingerprint"])
         assert active_fingerprint == secondary_fingerprint
+@pytest.mark.limit_consensus_modes(reason="does not depend on consensus rules")
+@pytest.mark.anyio
+async def test_mirrors(
+    self_hostname: str, one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices, tmp_path: Path
+) -> None:
+    wallet_rpc_api, full_node_api, wallet_rpc_port, ph, bt = await init_wallet_and_node(
+        self_hostname, one_wallet_and_one_simulator_services
+    )
+    async with init_data_layer(wallet_rpc_port=wallet_rpc_port, bt=bt, db_path=tmp_path) as data_layer:
+        data_rpc_api = DataLayerRpcApi(data_layer)
+        res = await data_rpc_api.create_data_store({})
+        assert res is not None
+        store_id = bytes32(hexstr_to_bytes(res["id"]))
+        await farm_block_check_singleton(data_layer, full_node_api, ph, store_id, wallet=wallet_rpc_api.service)
+        urls = ["http://127.0.0.1/8000", "http://127.0.0.1/8001"]
+        res = await data_rpc_api.add_mirror({"id": store_id.hex(), "urls": urls, "amount": 1, "fee": 1})
+        await farm_block_check_singleton(data_layer, full_node_api, ph, store_id, wallet=wallet_rpc_api.service)
+        mirrors = await data_rpc_api.get_mirrors({"id": store_id.hex()})
+        mirror_list = mirrors["mirrors"]
+        assert len(mirror_list) == 1
+        mirror = mirror_list[0]
+        assert mirror["urls"] == ["http://127.0.0.1/8000", "http://127.0.0.1/8001"]
+        coin_id = mirror["coin_id"]
+        res = await data_rpc_api.delete_mirror({"coin_id": coin_id, "fee": 1})
+        await farm_block_check_singleton(data_layer, full_node_api, ph, store_id, wallet=wallet_rpc_api.service)
+        mirrors = await data_rpc_api.get_mirrors({"id": store_id.hex()})
+        mirror_list = mirrors["mirrors"]
+        assert len(mirror_list) == 0
+        with pytest.raises(RuntimeError, match="URL list can't be empty"):
+            res = await data_rpc_api.add_mirror({"id": store_id.hex(), "urls": [], "amount": 1, "fee": 1})
+@dataclass(frozen=True)
+class ProofReference:
+    entries_to_insert: int
+    keys_to_prove: List[str]
+    verify_proof_response: Dict[str, Any]
+def populate_reference(count: int, keys_to_prove: int) -> ProofReference:
+    ret = ProofReference(
+        entries_to_insert=count,
+        keys_to_prove=[value.to_bytes(length=1, byteorder="big").hex() for value in range(keys_to_prove)],
+        verify_proof_response={
+            "current_root": True,
+            "success": True,
+            "verified_clvm_hashes": {
+                "store_id": "",
+                "inclusions": [
+                    {
+                        "key_clvm_hash": "0x" + std_hash(b"\1" + value.to_bytes(length=1, byteorder="big")).hex(),
+                        "value_clvm_hash": "0x"
+                        + std_hash(b"\1" + b"\x01" + value.to_bytes(length=1, byteorder="big")).hex(),
+                    }
+                    for value in range(keys_to_prove)
+                ],
+            },
+        },
+    )
+    return ret
+async def populate_proof_setup(offer_setup: OfferSetup, count: int) -> OfferSetup:
+    if count > 0:
+        # Only need data in the maker for proofs
+        value_prefix = b"\x01"
+        store_setup = offer_setup.maker
+        await store_setup.api.batch_update(
+            {
+                "id": store_setup.id.hex(),
+                "changelist": [
+                    {
+                        "action": "insert",
+                        "key": value.to_bytes(length=1, byteorder="big").hex(),
+                        "value": (value_prefix + value.to_bytes(length=1, byteorder="big")).hex(),
+                    }
+                    for value in range(count)
+                ],
+            }
+        )
+        await process_for_data_layer_keys(
+            expected_key=b"\x00",
+            full_node_api=offer_setup.full_node_api,
+            data_layer=offer_setup.maker.data_layer,
+            store_id=offer_setup.maker.id,
+        )
+    maker_original_singleton = await offer_setup.maker.data_layer.get_root(store_id=offer_setup.maker.id)
+    assert maker_original_singleton is not None
+    maker_original_root_hash = maker_original_singleton.root
+    return OfferSetup(
+        maker=StoreSetup(
+            api=offer_setup.maker.api,
+            id=offer_setup.maker.id,
+            original_hash=maker_original_root_hash,
+            data_layer=offer_setup.maker.data_layer,
+            data_rpc_client=offer_setup.maker.data_rpc_client,
+        ),
+        taker=StoreSetup(
+            api=offer_setup.taker.api,
+            id=offer_setup.taker.id,
+            original_hash=bytes32([0] * 32),
+            data_layer=offer_setup.taker.data_layer,
+            data_rpc_client=offer_setup.taker.data_rpc_client,
+        ),
+        full_node_api=offer_setup.full_node_api,
+    )
+@pytest.mark.parametrize(
+    argnames="reference",
+    argvalues=[
+        pytest.param(populate_reference(count=5, keys_to_prove=1), id="one key"),
+        pytest.param(populate_reference(count=5, keys_to_prove=2), id="two keys"),
+        pytest.param(populate_reference(count=5, keys_to_prove=5), id="five keys"),
+    ],
+)
+@pytest.mark.limit_consensus_modes(reason="does not depend on consensus rules")
+@pytest.mark.anyio
+async def test_dl_proof(offer_setup: OfferSetup, reference: ProofReference) -> None:
+    offer_setup = await populate_proof_setup(offer_setup=offer_setup, count=reference.entries_to_insert)
+    reference.verify_proof_response["verified_clvm_hashes"]["store_id"] = f"0x{offer_setup.maker.id.hex()}"
+    #
+    # Ideally this would use the InterfaceLayer as a parameterized list, however, all the fixtures
+    # are function scoped, which makes it very long to run this but this doesn't change any of the
+    # data, so rerunning all the setup for each test is not needed - module scope would be perfect
+    # but it requires all the supporting fixtures (wallet/nodes/etc) to have the same scope
+    #
+    # random tests for HashOnlyProof root()
+    fakeproof = HashOnlyProof(
+        key_clvm_hash=bytes32([1] * 32), value_clvm_hash=bytes32([1] * 32), node_hash=bytes32([3] * 32), layers=[]
+    )
+    assert fakeproof.root() == fakeproof.node_hash
+    fakeproof = HashOnlyProof(
+        key_clvm_hash=bytes32([1] * 32),
+        value_clvm_hash=bytes32([1] * 32),
+        node_hash=bytes32([3] * 32),
+        layers=[
+            ProofLayer(other_hash_side=uint8(0), other_hash=bytes32([1] * 32), combined_hash=bytes32([5] * 32)),
+            ProofLayer(other_hash_side=uint8(0), other_hash=bytes32([1] * 32), combined_hash=bytes32([7] * 32)),
+        ],
+    )
+    assert fakeproof.root() == bytes32([7] * 32)
+    # Test InterfaceLayer.direct
+    proof = await offer_setup.maker.api.get_proof(
+        request={"store_id": offer_setup.maker.id.hex(), "keys": reference.keys_to_prove}
+    )
+    assert proof["success"] is True
+    verify = await offer_setup.taker.api.verify_proof(request=proof["proof"])
+    assert verify == reference.verify_proof_response
+    # test InterfaceLayer.client
+    proof = dict()
+    verify = dict()
+    proof = await offer_setup.maker.data_rpc_client.get_proof(
+        store_id=offer_setup.maker.id, keys=[hexstr_to_bytes(key) for key in reference.keys_to_prove]
+    )
+    assert proof["success"] is True
+    verify = await offer_setup.taker.data_rpc_client.verify_proof(proof=proof["proof"])
+    assert verify == reference.verify_proof_response
+    # test InterfaceLayer.func
+    proof = dict()
+    verify = dict()
+    proof = await get_proof_cmd(
+        store_id=offer_setup.maker.id,
+        key_strings=reference.keys_to_prove,
+        rpc_port=offer_setup.maker.data_rpc_client.port,
+        root_path=offer_setup.maker.data_layer.root_path,
+    )
+    assert proof["success"] is True
+    verify = await verify_proof_cmd(
+        proof=proof["proof"],
+        rpc_port=offer_setup.taker.data_rpc_client.port,
+        root_path=offer_setup.taker.data_layer.root_path,
+    )
+    assert verify == reference.verify_proof_response
+    # test InterfaceLayer.cli
+    key_args: List[str] = []
+    for key in reference.keys_to_prove:
+        key_args.append("--key")
+        key_args.append(key)
+    process = await run_cli_cmd(
+        "data",
+        "get_proof",
+        "--id",
+        offer_setup.maker.id.hex(),
+        *key_args,
+        "--data-rpc-port",
+        str(offer_setup.maker.data_rpc_client.port),
+        root_path=offer_setup.maker.data_layer.root_path,
+    )
+    assert process.stdout is not None
+    raw_output = await process.stdout.read()
+    proof = json.loads(raw_output)
+    assert proof["success"] is True
+    process = await run_cli_cmd(
+        "data",
+        "verify_proof",
+        "-p",
+        json.dumps(proof["proof"]),
+        "--data-rpc-port",
+        str(offer_setup.taker.data_rpc_client.port),
+        root_path=offer_setup.taker.data_layer.root_path,
+    )
+    assert process.stdout is not None
+    raw_output = await process.stdout.read()
+    verify = json.loads(raw_output)
+    assert verify == reference.verify_proof_response
+@pytest.mark.limit_consensus_modes(reason="does not depend on consensus rules")
+@pytest.mark.anyio
+async def test_dl_proof_errors(
+    self_hostname: str, one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices, tmp_path: Path
+) -> None:
+    wallet_rpc_api, full_node_api, wallet_rpc_port, ph, bt = await init_wallet_and_node(
+        self_hostname, one_wallet_and_one_simulator_services
+    )
+    async with init_data_layer(wallet_rpc_port=wallet_rpc_port, bt=bt, db_path=tmp_path) as data_layer:
+        data_rpc_api = DataLayerRpcApi(data_layer)
+        fakeroot = bytes32([4] * 32)
+        res = await data_rpc_api.create_data_store({})
+        assert res is not None
+        store_id = bytes32(hexstr_to_bytes(res["id"]))
+        await farm_block_check_singleton(data_layer, full_node_api, ph, store_id, wallet=wallet_rpc_api.service)
+        with pytest.raises(ValueError, match="no root"):
+            await data_rpc_api.get_proof(request={"store_id": fakeroot.hex(), "keys": []})
+        with pytest.raises(KeyNotFoundError, match="Key not found"):
+            await data_rpc_api.get_proof(request={"store_id": store_id.hex(), "keys": [b"4".hex()]})
+@pytest.mark.limit_consensus_modes(reason="does not depend on consensus rules")
+@pytest.mark.anyio
+async def test_dl_proof_verify_errors(offer_setup: OfferSetup, seeded_random: random.Random) -> None:
+    two_key_proof = populate_reference(count=5, keys_to_prove=2)
+    offer_setup = await populate_proof_setup(offer_setup=offer_setup, count=two_key_proof.entries_to_insert)
+    two_key_proof.verify_proof_response["verified_clvm_hashes"]["store_id"] = f"0x{offer_setup.maker.id.hex()}"
+    proof = await offer_setup.maker.api.get_proof(
+        request={"store_id": offer_setup.maker.id.hex(), "keys": two_key_proof.keys_to_prove}
+    )
+    assert proof["success"] is True
+    verify = await offer_setup.taker.api.verify_proof(request=proof["proof"])
+    assert verify == two_key_proof.verify_proof_response
+    # test bad coin id
+    badproof = deepcopy(proof["proof"])
+    badproof["coin_id"] = bytes32.random(seeded_random).hex()
+    with pytest.raises(ValueError, match="Invalid Proof: No DL singleton found at coin id"):
+        await offer_setup.taker.api.verify_proof(request=badproof)
+    # test bad innerpuz
+    badproof = deepcopy(proof["proof"])
+    badproof["inner_puzzle_hash"] = bytes32.random(seeded_random).hex()
+    with pytest.raises(ValueError, match="Invalid Proof: incorrect puzzle hash"):
+        await offer_setup.taker.api.verify_proof(request=badproof)
+    # test bad key
+    badproof = deepcopy(proof["proof"])
+    badproof["store_proofs"]["proofs"][0]["key_clvm_hash"] = bytes32.random(seeded_random).hex()
+    with pytest.raises(ValueError, match="Invalid Proof: node hash does not match key and value"):
+        await offer_setup.taker.api.verify_proof(request=badproof)
+    # test bad value
+    badproof = deepcopy(proof["proof"])
+    badproof["store_proofs"]["proofs"][0]["value_clvm_hash"] = bytes32.random(seeded_random).hex()
+    with pytest.raises(ValueError, match="Invalid Proof: node hash does not match key and value"):
+        await offer_setup.taker.api.verify_proof(request=badproof)
+    # test bad layer hash
+    badproof = deepcopy(proof["proof"])
+    badproof["store_proofs"]["proofs"][0]["layers"][1]["other_hash"] = bytes32.random(seeded_random).hex()
+    with pytest.raises(ValueError, match="Invalid Proof: invalid proof of inclusion found"):
+        await offer_setup.taker.api.verify_proof(request=badproof)
+@pytest.mark.limit_consensus_modes(reason="does not depend on consensus rules")
+@pytest.mark.anyio
+async def test_dl_proof_changed_root(offer_setup: OfferSetup, seeded_random: random.Random) -> None:
+    two_key_proof = populate_reference(count=5, keys_to_prove=2)
+    offer_setup = await populate_proof_setup(offer_setup=offer_setup, count=two_key_proof.entries_to_insert)
+    two_key_proof.verify_proof_response["verified_clvm_hashes"]["store_id"] = f"0x{offer_setup.maker.id.hex()}"
+    proof = await offer_setup.maker.api.get_proof(
+        request={"store_id": offer_setup.maker.id.hex(), "keys": two_key_proof.keys_to_prove}
+    )
+    assert proof["success"] is True
+    verify = await offer_setup.taker.api.verify_proof(request=proof["proof"])
+    assert verify == two_key_proof.verify_proof_response
+    key = b"a"
+    value = b"\x00\x01"
+    changelist: List[Dict[str, str]] = [{"action": "insert", "key": key.hex(), "value": value.hex()}]
+    await offer_setup.maker.api.batch_update({"id": offer_setup.maker.id.hex(), "changelist": changelist})
+    await process_for_data_layer_keys(
+        expected_key=key,
+        expected_value=value,
+        full_node_api=offer_setup.full_node_api,
+        data_layer=offer_setup.maker.data_layer,
+        store_id=offer_setup.maker.id,
+    )
+    root_changed = await offer_setup.taker.api.verify_proof(request=proof["proof"])
+    assert root_changed == {**verify, "current_root": False}
+@pytest.mark.limit_consensus_modes(reason="does not depend on consensus rules")
+@pytest.mark.anyio
+async def test_pagination_rpcs(
+    self_hostname: str, one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices, tmp_path: Path
+) -> None:
+    wallet_rpc_api, full_node_api, wallet_rpc_port, ph, bt = await init_wallet_and_node(
+        self_hostname, one_wallet_and_one_simulator_services
+    )
+    # TODO: with this being a pseudo context manager'ish thing it doesn't actually handle shutdown
+    async with init_data_layer(wallet_rpc_port=wallet_rpc_port, bt=bt, db_path=tmp_path) as data_layer:
+        data_rpc_api = DataLayerRpcApi(data_layer)
+        res = await data_rpc_api.create_data_store({})
+        assert res is not None
+        store_id = bytes32(hexstr_to_bytes(res["id"]))
+        await farm_block_check_singleton(data_layer, full_node_api, ph, store_id, wallet=wallet_rpc_api.service)
+        key1 = b"aa"
+        value1 = b"\x01\x02"
+        key1_hash = key_hash(key1)
+        leaf_hash1 = leaf_hash(key1, value1)
+        changelist: List[Dict[str, str]] = [{"action": "insert", "key": key1.hex(), "value": value1.hex()}]
+        key2 = b"ba"
+        value2 = b"\x03\x02"
+        key2_hash = key_hash(key2)
+        leaf_hash2 = leaf_hash(key2, value2)
+        changelist.append({"action": "insert", "key": key2.hex(), "value": value2.hex()})
+        key3 = b"ccc"
+        value3 = b"\x04\x05"
+        changelist.append({"action": "insert", "key": key3.hex(), "value": value3.hex()})
+        leaf_hash3 = leaf_hash(key3, value3)
+        key4 = b"d"
+        value4 = b"\x06\x03"
+        key4_hash = key_hash(key4)
+        leaf_hash4 = leaf_hash(key4, value4)
+        changelist.append({"action": "insert", "key": key4.hex(), "value": value4.hex()})
+        key5 = b"e"
+        value5 = b"\x07\x01"
+        key5_hash = key_hash(key5)
+        leaf_hash5 = leaf_hash(key5, value5)
+        changelist.append({"action": "insert", "key": key5.hex(), "value": value5.hex()})
+        res = await data_rpc_api.batch_update({"id": store_id.hex(), "changelist": changelist})
+        update_tx_rec0 = res["tx_id"]
+        await farm_block_with_spend(full_node_api, ph, update_tx_rec0, wallet_rpc_api)
+        local_root = await data_rpc_api.get_local_root({"id": store_id.hex()})
+        keys_reference = {
+            "total_pages": 2,
+            "total_bytes": 9,
+            "keys": [],
+            "root_hash": local_root["hash"],
+        }
+        keys_paginated = await data_rpc_api.get_keys({"id": store_id.hex(), "page": 0, "max_page_size": 5})
+        assert key2_hash < key1_hash
+        assert keys_paginated == {**keys_reference, "keys": ["0x" + key3.hex(), "0x" + key2.hex()]}
+        keys_paginated = await data_rpc_api.get_keys({"id": store_id.hex(), "page": 1, "max_page_size": 5})
+        assert key5_hash < key4_hash
+        assert keys_paginated == {**keys_reference, "keys": ["0x" + key1.hex(), "0x" + key5.hex(), "0x" + key4.hex()]}
+        keys_paginated = await data_rpc_api.get_keys({"id": store_id.hex(), "page": 2, "max_page_size": 5})
+        assert keys_paginated == keys_reference
+        keys_values_reference = {
+            "total_pages": 3,
+            "total_bytes": 19,
+            "keys_values": [],
+            "root_hash": local_root["hash"],
+        }
+        keys_values_paginated = await data_rpc_api.get_keys_values(
+            {"id": store_id.hex(), "page": 0, "max_page_size": 8},
+        )
+        expected_kv = [
+            {"atom": None, "hash": "0x" + leaf_hash3.hex(), "key": "0x" + key3.hex(), "value": "0x" + value3.hex()},
+        ]
+        assert keys_values_paginated == {**keys_values_reference, "keys_values": expected_kv}
+        keys_values_paginated = await data_rpc_api.get_keys_values(
+            {"id": store_id.hex(), "page": 1, "max_page_size": 8}
+        )
+        expected_kv = [
+            {"atom": None, "hash": "0x" + leaf_hash1.hex(), "key": "0x" + key1.hex(), "value": "0x" + value1.hex()},
+            {"atom": None, "hash": "0x" + leaf_hash2.hex(), "key": "0x" + key2.hex(), "value": "0x" + value2.hex()},
+        ]
+        assert leaf_hash1 < leaf_hash2
+        assert keys_values_paginated == {**keys_values_reference, "keys_values": expected_kv}
+        keys_values_paginated = await data_rpc_api.get_keys_values(
+            {"id": store_id.hex(), "page": 2, "max_page_size": 8}
+        )
+        expected_kv = [
+            {"atom": None, "hash": "0x" + leaf_hash5.hex(), "key": "0x" + key5.hex(), "value": "0x" + value5.hex()},
+            {"atom": None, "hash": "0x" + leaf_hash4.hex(), "key": "0x" + key4.hex(), "value": "0x" + value4.hex()},
+        ]
+        assert leaf_hash5 < leaf_hash4
+        assert keys_values_paginated == {**keys_values_reference, "keys_values": expected_kv}
+        keys_values_paginated = await data_rpc_api.get_keys_values(
+            {"id": store_id.hex(), "page": 3, "max_page_size": 8}
+        )
+        assert keys_values_paginated == keys_values_reference
+        key6 = b"ab"
+        value6 = b"\x01\x01"
+        leaf_hash6 = leaf_hash(key6, value6)
+        key7 = b"ac"
+        value7 = b"\x01\x01"
+        leaf_hash7 = leaf_hash(key7, value7)
+        changelist = [{"action": "delete", "key": key3.hex()}]
+        changelist.append({"action": "insert", "key": key6.hex(), "value": value6.hex()})
+        changelist.append({"action": "insert", "key": key7.hex(), "value": value7.hex()})
+        res = await data_rpc_api.batch_update({"id": store_id.hex(), "changelist": changelist})
+        update_tx_rec1 = res["tx_id"]
+        await farm_block_with_spend(full_node_api, ph, update_tx_rec1, wallet_rpc_api)
+        history = await data_rpc_api.get_root_history({"id": store_id.hex()})
+        hash1 = history["root_history"][1]["root_hash"]
+        hash2 = history["root_history"][2]["root_hash"]
+        diff_reference = {
+            "total_pages": 3,
+            "total_bytes": 13,
+            "diff": [],
+        }
+        diff_res = await data_rpc_api.get_kv_diff(
+            {
+                "id": store_id.hex(),
+                "hash_1": hash1.hex(),
+                "hash_2": hash2.hex(),
+                "page": 0,
+                "max_page_size": 5,
+            }
+        )
+        expected_diff = [{"type": "DELETE", "key": key3.hex(), "value": value3.hex()}]
+        assert diff_res == {**diff_reference, "diff": expected_diff}
+        diff_res = await data_rpc_api.get_kv_diff(
+            {
+                "id": store_id.hex(),
+                "hash_1": hash1.hex(),
+                "hash_2": hash2.hex(),
+                "page": 1,
+                "max_page_size": 5,
+            }
+        )
+        assert leaf_hash6 < leaf_hash7
+        expected_diff = [{"type": "INSERT", "key": key6.hex(), "value": value6.hex()}]
+        assert diff_res == {**diff_reference, "diff": expected_diff}
+        diff_res = await data_rpc_api.get_kv_diff(
+            {
+                "id": store_id.hex(),
+                "hash_1": hash1.hex(),
+                "hash_2": hash2.hex(),
+                "page": 2,
+                "max_page_size": 5,
+            }
+        )
+        expected_diff = [{"type": "INSERT", "key": key7.hex(), "value": value7.hex()}]
+        assert diff_res == {**diff_reference, "diff": expected_diff}
+        diff_res = await data_rpc_api.get_kv_diff(
+            {
+                "id": store_id.hex(),
+                "hash_1": hash1.hex(),
+                "hash_2": hash2.hex(),
+                "page": 3,
+                "max_page_size": 5,
+            }
+        )
+        assert diff_res == diff_reference
+        diff_res = await data_rpc_api.get_kv_diff(
+            {
+                "id": store_id.hex(),
+                "hash_1": hash1.hex(),
+                "hash_2": bytes32([0] * 31 + [1]).hex(),
+                "page": 0,
+                "max_page_size": 10,
+            }
+        )
+        empty_diff_reference = {
+            "total_pages": 1,
+            "total_bytes": 0,
+            "diff": [],
+        }
+        assert diff_res == empty_diff_reference
+        diff_res = await data_rpc_api.get_kv_diff(
+            {
+                "id": store_id.hex(),
+                "hash_1": bytes32([0] * 31 + [1]).hex(),
+                "hash_2": hash2.hex(),
+                "page": 0,
+                "max_page_size": 10,
+            }
+        )
+        assert diff_res == empty_diff_reference
+        new_value = b"\x02\x02"
+        changelist = [{"action": "upsert", "key": key6.hex(), "value": new_value.hex()}]
+        new_leaf_hash = leaf_hash(key6, new_value)
+        res = await data_rpc_api.batch_update({"id": store_id.hex(), "changelist": changelist})
+        update_tx_rec3 = res["tx_id"]
+        await farm_block_with_spend(full_node_api, ph, update_tx_rec3, wallet_rpc_api)
+        history = await data_rpc_api.get_root_history({"id": store_id.hex()})
+        hash1 = history["root_history"][2]["root_hash"]
+        hash2 = history["root_history"][3]["root_hash"]
+        diff_res = await data_rpc_api.get_kv_diff(
+            {
+                "id": store_id.hex(),
+                "hash_1": hash1.hex(),
+                "hash_2": hash2.hex(),
+                "page": 0,
+                "max_page_size": 100,
+            }
+        )
+        assert leaf_hash6 < new_leaf_hash
+        diff_reference = {
+            "total_pages": 1,
+            "total_bytes": 8,
+            "diff": [
+                {"type": "DELETE", "key": key6.hex(), "value": value6.hex()},
+                {"type": "INSERT", "key": key6.hex(), "value": new_value.hex()},
+            ],
+        }
+        assert diff_res == diff_reference
+        with pytest.raises(Exception, match="Can't find keys"):
+            await data_rpc_api.get_keys(
+                {"id": store_id.hex(), "page": 0, "max_page_size": 100, "root_hash": bytes32([0] * 31 + [1]).hex()}
+            )
+        with pytest.raises(Exception, match="Can't find keys and values"):
+            await data_rpc_api.get_keys_values(
+                {"id": store_id.hex(), "page": 0, "max_page_size": 100, "root_hash": bytes32([0] * 31 + [1]).hex()}
+            )
+        with pytest.raises(RuntimeError, match="Cannot paginate data, item size is larger than max page size"):
+            keys_paginated = await data_rpc_api.get_keys_values({"id": store_id.hex(), "page": 0, "max_page_size": 1})
+        with pytest.raises(RuntimeError, match="Cannot paginate data, item size is larger than max page size"):
+            keys_values_paginated = await data_rpc_api.get_keys_values(
+                {"id": store_id.hex(), "page": 0, "max_page_size": 1}
+            )
+        with pytest.raises(RuntimeError, match="Cannot paginate data, item size is larger than max page size"):
+            diff_res = await data_rpc_api.get_kv_diff(
+                {
+                    "id": store_id.hex(),
+                    "hash_1": hash1.hex(),
+                    "hash_2": hash2.hex(),
+                    "page": 0,
+                    "max_page_size": 1,
+                }
+            )
+@pytest.mark.limit_consensus_modes(reason="does not depend on consensus rules")
+@pytest.mark.parametrize(argnames="layer", argvalues=[InterfaceLayer.funcs, InterfaceLayer.cli, InterfaceLayer.client])
+@pytest.mark.parametrize(argnames="max_page_size", argvalues=[5, 100, None])
+@pytest.mark.anyio
+async def test_pagination_cmds(
+    self_hostname: str,
+    one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices,
+    tmp_path: Path,
+    layer: InterfaceLayer,
+    max_page_size: Optional[int],
+    bt: BlockTools,
+) -> None:
+    wallet_rpc_api, full_node_api, wallet_rpc_port, ph, bt = await init_wallet_and_node(
+        self_hostname, one_wallet_and_one_simulator_services
+    )
+    async with init_data_layer_service(wallet_rpc_port=wallet_rpc_port, bt=bt, db_path=tmp_path) as data_layer_service:
+        assert data_layer_service.rpc_server is not None
+        rpc_port = data_layer_service.rpc_server.listen_port
+        data_layer = data_layer_service._api.data_layer
+        data_rpc_api = DataLayerRpcApi(data_layer)
+        res = await data_rpc_api.create_data_store({})
+        assert res is not None
+        store_id = bytes32(hexstr_to_bytes(res["id"]))
+        await farm_block_check_singleton(data_layer, full_node_api, ph, store_id, wallet=wallet_rpc_api.service)
+        key = b"aa"
+        value = b"aa"
+        key_2 = b"aaaa"
+        value_2 = b"a"
+        changelist = [
+            {"action": "insert", "key": key.hex(), "value": value.hex()},
+            {"action": "insert", "key": key_2.hex(), "value": value_2.hex()},
+        ]
+        res = await data_rpc_api.batch_update({"id": store_id.hex(), "changelist": changelist})
+        update_tx_rec0 = res["tx_id"]
+        await farm_block_with_spend(full_node_api, ph, update_tx_rec0, wallet_rpc_api)
+        local_root = await data_rpc_api.get_local_root({"id": store_id.hex()})
+        hash_1 = bytes32([0] * 32)
+        hash_2 = local_root["hash"]
+        # `InterfaceLayer.direct` is not tested here since test `test_pagination_rpcs` extensively use it.
+        if layer == InterfaceLayer.funcs:
+            keys = await get_keys_cmd(
+                rpc_port=rpc_port,
+                store_id="0x" + store_id.hex(),
+                root_hash=None,
+                fingerprint=None,
+                page=0,
+                max_page_size=max_page_size,
+                root_path=bt.root_path,
+            )
+            keys_values = await get_keys_values_cmd(
+                rpc_port=rpc_port,
+                store_id="0x" + store_id.hex(),
+                root_hash=None,
+                fingerprint=None,
+                page=0,
+                max_page_size=max_page_size,
+                root_path=bt.root_path,
+            )
+            kv_diff = await get_kv_diff_cmd(
+                rpc_port=rpc_port,
+                store_id="0x" + store_id.hex(),
+                hash_1="0x" + hash_1.hex(),
+                hash_2="0x" + hash_2.hex(),
+                fingerprint=None,
+                page=0,
+                max_page_size=max_page_size,
+                root_path=bt.root_path,
+            )
+        elif layer == InterfaceLayer.cli:
+            for command in ("get_keys", "get_keys_values", "get_kv_diff"):
+                if command == "get_keys" or command == "get_keys_values":
+                    args: List[str] = [
+                        sys.executable,
+                        "-m",
+                        "chia",
+                        "data",
+                        command,
+                        "--id",
+                        store_id.hex(),
+                        "--data-rpc-port",
+                        str(rpc_port),
+                        "--page",
+                        "0",
+                    ]
+                else:
+                    args = [
+                        sys.executable,
+                        "-m",
+                        "chia",
+                        "data",
+                        command,
+                        "--id",
+                        store_id.hex(),
+                        "--hash_1",
+                        "0x" + hash_1.hex(),
+                        "--hash_2",
+                        "0x" + hash_2.hex(),
+                        "--data-rpc-port",
+                        str(rpc_port),
+                        "--page",
+                        "0",
+                    ]
+                if max_page_size is not None:
+                    args.append("--max-page-size")
+                    args.append(f"{max_page_size}")
+                process = await asyncio.create_subprocess_exec(
+                    *args,
+                    env={**os.environ, "CHIA_ROOT": str(bt.root_path)},
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                await process.wait()
+                assert process.stdout is not None
+                assert process.stderr is not None
+                stdout = await process.stdout.read()
+                stderr = await process.stderr.read()
+                if command == "get_keys":
+                    keys = json.loads(stdout)
+                elif command == "get_keys_values":
+                    keys_values = json.loads(stdout)
+                else:
+                    kv_diff = json.loads(stdout)
+                assert process.returncode == 0
+                if sys.version_info >= (3, 10, 6):
+                    assert stderr == b""
+                else:  # pragma: no cover
+                    # https://github.com/python/cpython/issues/92841
+                    assert stderr == b"" or b"_ProactorBasePipeTransport.__del__" in stderr
+        elif layer == InterfaceLayer.client:
+            client = await DataLayerRpcClient.create(
+                self_hostname=self_hostname,
+                port=rpc_port,
+                root_path=bt.root_path,
+                net_config=bt.config,
+            )
+            try:
+                keys = await client.get_keys(
+                    store_id=store_id,
+                    root_hash=None,
+                    page=0,
+                    max_page_size=max_page_size,
+                )
+                keys_values = await client.get_keys_values(
+                    store_id=store_id,
+                    root_hash=None,
+                    page=0,
+                    max_page_size=max_page_size,
+                )
+                kv_diff = await client.get_kv_diff(
+                    store_id=store_id,
+                    hash_1=hash_1,
+                    hash_2=hash_2,
+                    page=0,
+                    max_page_size=max_page_size,
+                )
+            finally:
+                client.close()
+                await client.await_closed()
+        else:  # pragma: no cover
+            assert False, "unhandled parametrization"
+        if max_page_size is None or max_page_size == 100:
+            assert keys == {
+                "keys": ["0x61616161", "0x6161"],
+                "root_hash": "0x3f4ae7b8e10ef48b3114843537d5def989ee0a3b6568af7e720a71730f260fa1",
+                "success": True,
+                "total_bytes": 6,
+                "total_pages": 1,
+            }
+            assert keys_values == {
+                "keys_values": [
+                    {
+                        "atom": None,
+                        "hash": "0x3c8ecfd41a1c54820f5ad687a4cbfbad0faa78445cbf31ec4f879ce553216a9d",
+                        "key": "0x61616161",
+                        "value": "0x61",
+                    },
+                    {
+                        "atom": None,
+                        "hash": "0x5a7edd8e4bc28e32ba2a2514054f3872037a4f6da52c5a662969b6b881beaa3f",
+                        "key": "0x6161",
+                        "value": "0x6161",
+                    },
+                ],
+                "root_hash": "0x3f4ae7b8e10ef48b3114843537d5def989ee0a3b6568af7e720a71730f260fa1",
+                "success": True,
+                "total_bytes": 9,
+                "total_pages": 1,
+            }
+            assert kv_diff == {
+                "diff": [
+                    {"key": "61616161", "type": "INSERT", "value": "61"},
+                    {"key": "6161", "type": "INSERT", "value": "6161"},
+                ],
+                "success": True,
+                "total_bytes": 9,
+                "total_pages": 1,
+            }
+        elif max_page_size == 5:
+            assert keys == {
+                "keys": ["0x61616161"],
+                "root_hash": "0x3f4ae7b8e10ef48b3114843537d5def989ee0a3b6568af7e720a71730f260fa1",
+                "success": True,
+                "total_bytes": 6,
+                "total_pages": 2,
+            }
+            assert keys_values == {
+                "keys_values": [
+                    {
+                        "atom": None,
+                        "hash": "0x3c8ecfd41a1c54820f5ad687a4cbfbad0faa78445cbf31ec4f879ce553216a9d",
+                        "key": "0x61616161",
+                        "value": "0x61",
+                    }
+                ],
+                "root_hash": "0x3f4ae7b8e10ef48b3114843537d5def989ee0a3b6568af7e720a71730f260fa1",
+                "success": True,
+                "total_bytes": 9,
+                "total_pages": 2,
+            }
+            assert kv_diff == {
+                "diff": [
+                    {"key": "61616161", "type": "INSERT", "value": "61"},
+                ],
+                "success": True,
+                "total_bytes": 9,
+                "total_pages": 2,
+            }
+        else:  # pragma: no cover
+            assert False, "unhandled parametrization"

tests/core/data_layer/test_data_store.py CHANGED Viewed

         @@@ -308,7 -314,7 +308,8 @@@ async def test_get_ancestors_optimized(
         if i > 25 and i <= 200 and random.randint(0, 4):
             is_insert = True
         if i > 200:
-            hint_keys_values = await data_store.get_keys_values_compressed(tree_id)
-            hint_keys_values = await data_store.get_keys_values_dict(tree_id)
+            kv_compressed = await data_store.get_keys_values_compressed(tree_id=tree_id)
+            hint_keys_values = kv_compressed.keys_values_hashed
             if not deleted_all:
                 while node_count > 0:
                     node_count -= 1
         @@@ -643,7 -559,7 +644,8 @@@ async def test_inserting_duplicate_key_
             side=Side.RIGHT,
         )
-    hint_keys_values = await data_store.get_keys_values_compressed(tree_id=tree_id)
-    hint_keys_values = await data_store.get_keys_values_dict(tree_id=tree_id)
+    kv_compressed = await data_store.get_keys_values_compressed(tree_id=tree_id)
+    hint_keys_values = kv_compressed.keys_values_hashed
     # TODO: more specific exception
     with pytest.raises(Exception):
         await data_store.insert(
         @@@ -749,7 -665,7 +751,8 @@@ async def test_delete_from_left_both_te
     hint_keys_values = None
     if use_hint:
-        hint_keys_values = await data_store.get_keys_values_compressed(tree_id=tree_id)
-        hint_keys_values = await data_store.get_keys_values_dict(tree_id=tree_id)
+        kv_compressed = await data_store.get_keys_values_compressed(tree_id=tree_id)
+        hint_keys_values = kv_compressed.keys_values_hashed
     expected = Program.to(
         (
         @@@ -789,7 -707,7 +792,8 @@@ async def test_delete_from_left_other_n
     hint_keys_values = None
     if use_hint:
-        hint_keys_values = await data_store.get_keys_values_compressed(tree_id=tree_id)
-        hint_keys_values = await data_store.get_keys_values_dict(tree_id=tree_id)
+        kv_compressed = await data_store.get_keys_values_compressed(tree_id=tree_id)
+        hint_keys_values = kv_compressed.keys_values_hashed
     expected = Program.to(
         (
         @@@ -827,7 -749,7 +831,8 @@@ async def test_delete_from_right_both_t
     hint_keys_values = None
     if use_hint:
-        hint_keys_values = await data_store.get_keys_values_compressed(tree_id=tree_id)
-        hint_keys_values = await data_store.get_keys_values_dict(tree_id=tree_id)
+        kv_compressed = await data_store.get_keys_values_compressed(tree_id=tree_id)
+        hint_keys_values = kv_compressed.keys_values_hashed
     expected = Program.to(
         (
         @@@ -867,7 -791,7 +872,8 @@@ async def test_delete_from_right_other_
     hint_keys_values = None
     if use_hint:
-        hint_keys_values = await data_store.get_keys_values_compressed(tree_id=tree_id)
-        hint_keys_values = await data_store.get_keys_values_dict(tree_id=tree_id)
+        kv_compressed = await data_store.get_keys_values_compressed(tree_id=tree_id)
+        hint_keys_values = kv_compressed.keys_values_hashed
     expected = Program.to(
         (

tests/core/full_node/stores/test_coin_store.py CHANGED Viewed

         @@@ -499,341 -493,8 +499,341 @@@ async def test_get_coin_states(db_versi
         assert len(await coin_store.get_coin_states_by_ids(True, coins, uint32(0), max_items=10000)) == 600
+@dataclass(frozen=True)
+class RandomCoinRecords:
+    items: List[CoinRecord]
+    puzzle_hashes: List[bytes32]
+    hints: List[Tuple[bytes32, bytes]]
+@pytest.fixture(scope="session")
+def random_coin_records() -> RandomCoinRecords:
+    coin_records: List[CoinRecord] = []
+    puzzle_hashes: List[bytes32] = []
+    hints: List[Tuple[bytes32, bytes]] = []
+    for i in range(50000):
+        is_spent = i % 2 == 0
+        is_hinted = i % 7 == 0
+        created_height = uint32(i)
+        spent_height = uint32(created_height + 100)
+        puzzle_hash = std_hash(i.to_bytes(4, byteorder="big"))
+        coin = Coin(
+            std_hash(b"Parent Coin Id " + i.to_bytes(4, byteorder="big")),
+            puzzle_hash,
+            uint64(1000),
+        )
+        if is_hinted:
+            hint = std_hash(b"Hinted " + puzzle_hash)
+            hints.append((coin.name(), hint))
+            puzzle_hashes.append(hint)
+        else:
+            puzzle_hashes.append(puzzle_hash)
+        coin_records.append(
+            CoinRecord(
+                coin=coin,
+                confirmed_block_index=created_height,
+                spent_block_index=spent_height if is_spent else uint32(0),
+                coinbase=False,
+                timestamp=uint64(0),
+            )
+        )
+    coin_records.sort(key=lambda cr: max(cr.confirmed_block_index, cr.spent_block_index))
+    return RandomCoinRecords(coin_records, puzzle_hashes, hints)
+@pytest.mark.anyio
+@pytest.mark.parametrize("include_spent", [True, False])
+@pytest.mark.parametrize("include_unspent", [True, False])
+@pytest.mark.parametrize("include_hinted", [True, False])
+async def test_coin_state_batches(
+    db_version: int,
+    random_coin_records: RandomCoinRecords,
+    include_spent: bool,
+    include_unspent: bool,
+    include_hinted: bool,
+) -> None:
+    async with DBConnection(db_version) as db_wrapper:
+        # Initialize coin and hint stores.
+        coin_store = await CoinStore.create(db_wrapper)
+        hint_store = await HintStore.create(db_wrapper)
+        await coin_store._add_coin_records(random_coin_records.items)
+        await hint_store.add_hints(random_coin_records.hints)
+        # Make sure all of the coin states are found when batching.
+        ph_set = set(random_coin_records.puzzle_hashes)
+        expected_crs = []
+        for cr in random_coin_records.items:
+            if cr.spent_block_index == 0 and not include_unspent:
+                continue
+            if cr.spent_block_index > 0 and not include_spent:
+                continue
+            if cr.coin.puzzle_hash not in ph_set and not include_hinted:
+                continue
+            expected_crs.append(cr)
+        height: Optional[uint32] = uint32(0)
+        all_coin_states: List[CoinState] = []
+        remaining_phs = random_coin_records.puzzle_hashes.copy()
+        def height_of(coin_state: CoinState) -> int:
+            return max(coin_state.created_height or 0, coin_state.spent_height or 0)
+        while height is not None:
+            (coin_states, height) = await coin_store.batch_coin_states_by_puzzle_hashes(
+                remaining_phs[:15000],
+                min_height=height,
+                include_spent=include_spent,
+                include_unspent=include_unspent,
+                include_hinted=include_hinted,
+            )
+            # Ensure that all of the returned coin states are in order.
+            assert all(height_of(coin_states[i]) <= height_of(coin_states[i + 1]) for i in range(len(coin_states) - 1))
+            all_coin_states += coin_states
+            if height is None:
+                remaining_phs = remaining_phs[15000:]
+                if len(remaining_phs) > 0:
+                    height = uint32(0)
+        assert len(all_coin_states) == len(expected_crs)
+        all_coin_states.sort(key=height_of)
+        for i in range(len(expected_crs)):
+            actual = all_coin_states[i]
+            expected = expected_crs[i]
+            assert actual.coin == expected.coin, i
+            assert uint32(actual.created_height or 0) == expected.confirmed_block_index, i
+            assert uint32(actual.spent_height or 0) == expected.spent_block_index, i
+@pytest.mark.anyio
+@pytest.mark.parametrize("cut_off_middle", [True, False])
+async def test_batch_many_coin_states(db_version: int, cut_off_middle: bool) -> None:
+    async with DBConnection(db_version) as db_wrapper:
+        ph = bytes32(b"0" * 32)
+        # Generate coin records.
+        coin_records: List[CoinRecord] = []
+        count = 50000
+        for i in range(count):
+            # Create coin records at either height 10 or 12.
+            created_height = uint32((i % 2) * 2 + 10)
+            coin = Coin(
+                std_hash(b"Parent Coin Id " + i.to_bytes(4, byteorder="big")),
+                ph,
+                uint64(i),
+            )
+            coin_records.append(
+                CoinRecord(
+                    coin=coin,
+                    confirmed_block_index=created_height,
+                    spent_block_index=uint32(0),
+                    coinbase=False,
+                    timestamp=uint64(0),
+                )
+            )
+        # Initialize coin and hint stores.
+        coin_store = await CoinStore.create(db_wrapper)
+        await HintStore.create(db_wrapper)
+        await coin_store._add_coin_records(coin_records)
+        # Make sure all of the coin states are found.
+        (all_coin_states, next_height) = await coin_store.batch_coin_states_by_puzzle_hashes([ph])
+        all_coin_states.sort(key=lambda cs: cs.coin.amount)
+        assert next_height is None
+        assert len(all_coin_states) == len(coin_records)
+        for i in range(min(len(coin_records), len(all_coin_states))):
+            assert coin_records[i].coin.name().hex() == all_coin_states[i].coin.name().hex(), i
+        # For the middle case, insert a coin record between the two heights 10 and 12.
+        await coin_store._add_coin_records(
+            [
+                CoinRecord(
-                    coin=Coin(std_hash(b"extra coin"), ph, 0),
+                    coin=Coin(std_hash(b"extra coin"), ph, uint64(0)),
+                    # Insert a coin record in the middle between heights 10 and 12.
+                    # Or after all of the other coins if testing the batch limit.
+                    confirmed_block_index=uint32(11 if cut_off_middle else 50),
+                    spent_block_index=uint32(0),
+                    coinbase=False,
+                    timestamp=uint64(0),
+                )
+            ]
+        )
+        (all_coin_states, next_height) = await coin_store.batch_coin_states_by_puzzle_hashes([ph])
+        # Make sure that the extra coin records are not included in the results.
+        assert next_height == (12 if cut_off_middle else 50)
+        assert len(all_coin_states) == (25001 if cut_off_middle else 50000)
 @pytest.mark.anyio
 async def test_unsupported_version() -> None:
     with pytest.raises(RuntimeError, match="CoinStore does not support database schema v1"):
         async with DBConnection(1) as db_wrapper:
             await CoinStore.create(db_wrapper)
+TEST_COIN_ID = b"c" * 32
+TEST_PUZZLEHASH = b"p" * 32
-TEST_AMOUNT = 1337
+TEST_AMOUNT = uint64(1337)
+TEST_PARENT_ID = Coin(b"a" * 32, TEST_PUZZLEHASH, TEST_AMOUNT).name()
-TEST_PARENT_DIFFERENT_AMOUNT = 5
+TEST_PARENT_DIFFERENT_AMOUNT = uint64(5)
+TEST_PARENT_ID_DIFFERENT_AMOUNT = Coin(b"a" * 32, TEST_PUZZLEHASH, TEST_PARENT_DIFFERENT_AMOUNT).name()
+TEST_PARENT_PARENT_ID = b"f" * 32
+@dataclass(frozen=True)
+class UnspentLineageInfoTestItem:
+    coin_id: bytes
+    puzzlehash: bytes
+    amount: int
+    parent_id: bytes
+    is_spent: bool = False
+@dataclass
+class UnspentLineageInfoCase:
+    id: str
+    items: List[UnspentLineageInfoTestItem]
+    expected_success: bool
+    parent_with_diff_amount: bool = False
+    marks: Marks = ()
+@pytest.mark.anyio
+@datacases(
+    UnspentLineageInfoCase(
+        id="Unspent with parent that has same amount but different puzzlehash",
+        items=[
+            UnspentLineageInfoTestItem(TEST_COIN_ID, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_ID),
+            UnspentLineageInfoTestItem(b"2" * 32, b"2" * 32, 2, b"1" * 32),
+            UnspentLineageInfoTestItem(b"3" * 32, b"3" * 32, 3, b"2" * 32),
+            UnspentLineageInfoTestItem(TEST_PARENT_ID, b"4" * 32, TEST_AMOUNT, TEST_PARENT_PARENT_ID, is_spent=True),
+        ],
+        expected_success=False,
+    ),
+    UnspentLineageInfoCase(
+        id="Unspent with parent that has same puzzlehash but different amount",
+        items=[
+            UnspentLineageInfoTestItem(TEST_COIN_ID, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_ID_DIFFERENT_AMOUNT),
+            UnspentLineageInfoTestItem(b"2" * 32, b"2" * 32, 2, b"1" * 32),
+            UnspentLineageInfoTestItem(b"3" * 32, b"3" * 32, 3, b"2" * 32),
+            UnspentLineageInfoTestItem(
+                TEST_PARENT_ID_DIFFERENT_AMOUNT,
+                TEST_PUZZLEHASH,
+                TEST_PARENT_DIFFERENT_AMOUNT,
+                TEST_PARENT_PARENT_ID,
+                is_spent=True,
+            ),
+        ],
+        parent_with_diff_amount=True,
+        expected_success=True,
+    ),
+    UnspentLineageInfoCase(
+        id="Unspent with parent that has same puzzlehash and amount but is also unspent",
+        items=[
+            UnspentLineageInfoTestItem(TEST_COIN_ID, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_ID),
+            UnspentLineageInfoTestItem(b"2" * 32, b"2" * 32, 2, b"1" * 32),
+            UnspentLineageInfoTestItem(b"3" * 32, b"3" * 32, 3, b"2" * 32),
+            UnspentLineageInfoTestItem(TEST_PARENT_ID, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_PARENT_ID),
+        ],
+        expected_success=False,
+    ),
+    UnspentLineageInfoCase(
+        id="More than one unspent with parent that has same puzzlehash and amount",
+        items=[
+            UnspentLineageInfoTestItem(TEST_COIN_ID, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_ID),
+            UnspentLineageInfoTestItem(b"2" * 32, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_ID),
+            UnspentLineageInfoTestItem(b"3" * 32, b"3" * 32, 3, b"2" * 32),
+            UnspentLineageInfoTestItem(
+                TEST_PARENT_ID, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_PARENT_ID, is_spent=True
+            ),
+        ],
+        expected_success=False,
+    ),
+    UnspentLineageInfoCase(
+        id="Unspent with parent that has same puzzlehash and amount",
+        items=[
+            UnspentLineageInfoTestItem(TEST_COIN_ID, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_ID),
+            UnspentLineageInfoTestItem(b"2" * 32, b"2" * 32, 2, b"1" * 32),
+            UnspentLineageInfoTestItem(b"3" * 32, b"3" * 32, 3, b"2" * 32),
+            UnspentLineageInfoTestItem(
+                TEST_PARENT_ID, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_PARENT_ID, is_spent=True
+            ),
+        ],
+        expected_success=True,
+    ),
+)
+async def test_get_unspent_lineage_info_for_puzzle_hash(case: UnspentLineageInfoCase) -> None:
+    CoinRecordRawData = Tuple[
+        bytes,  # coin_name (blob)
+        int,  # confirmed_index (bigint)
+        int,  # spent_index (bigint)
+        int,  # coinbase (int)
+        bytes,  # puzzle_hash (blob)
+        bytes,  # coin_parent (blob)
+        bytes,  # amount (blob)
+        int,  # timestamp (bigint)
+    ]
+    def make_test_data(test_items: List[UnspentLineageInfoTestItem]) -> List[CoinRecordRawData]:
+        test_data = []
+        for item in test_items:
+            test_data.append(
+                (
+                    item.coin_id,
+                    0,
+                    1 if item.is_spent else 0,
+                    0,
+                    item.puzzlehash,
+                    item.parent_id,
+                    int_to_bytes(item.amount),
+                    0,
+                )
+            )
+        return test_data
+    async with DBConnection(2) as db_wrapper:
+        # Prepare the coin store with the test case's data
+        coin_store = await CoinStore.create(db_wrapper)
+        async with db_wrapper.writer() as writer:
+            for item in make_test_data(case.items):
+                await writer.execute(
+                    "INSERT INTO coin_record "
+                    "(coin_name, confirmed_index, spent_index, coinbase, puzzle_hash, coin_parent, amount, timestamp) "
+                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+                    item,
+                )
+        # Run the test case
+        result = await coin_store.get_unspent_lineage_info_for_puzzle_hash(bytes32(TEST_PUZZLEHASH))
+        if case.expected_success:
+            assert result == UnspentLineageInfo(
+                coin_id=bytes32(TEST_COIN_ID),
+                coin_amount=TEST_AMOUNT,
+                parent_id=bytes32(TEST_PARENT_ID_DIFFERENT_AMOUNT)
+                if case.parent_with_diff_amount
+                else bytes32(TEST_PARENT_ID),
+                parent_amount=TEST_PARENT_DIFFERENT_AMOUNT if case.parent_with_diff_amount else TEST_AMOUNT,
+                parent_parent_id=bytes32(TEST_PARENT_PARENT_ID),
+            )
+        else:
+            assert result is None

tests/core/full_node/test_conditions.py CHANGED Viewed

         @@@ -137,7 -145,7 +137,7 @@@ class TestConditions
     async def test_unknown_conditions_with_cost(
         self, opcode: int, expected_cost: int, bt: BlockTools, consensus_mode: ConsensusMode
     ) -> None:
-        conditions = Program.to(assemble(f"(({opcode} 1337))"))  # type: ignore[no-untyped-call]
+        conditions = Program.to(assemble(f"(({opcode} 1337))"))
         additions, removals, new_block = await check_conditions(bt, conditions)
         if consensus_mode != ConsensusMode.HARD_FORK_2_0:
         @@@ -164,7 -172,7 +164,7 @@@
     async def test_softfork_condition(
         self, condition: str, expected_cost: int, bt: BlockTools, consensus_mode: ConsensusMode
     ) -> None:
-        conditions = Program.to(assemble(condition))  # type: ignore[no-untyped-call]
+        conditions = Program.to(assemble(condition))
         additions, removals, new_block = await check_conditions(bt, conditions)
         if consensus_mode != ConsensusMode.HARD_FORK_2_0:
         @@@ -267,56 -275,56 +267,48 @@@
         ],
     )
     async def test_condition(self, opcode: ConditionOpcode, value: int, expected: Err, bt: BlockTools) -> None:
-        conditions = Program.to(assemble(f"(({opcode[0]} {value}))"))  # type: ignore[no-untyped-call]
+        conditions = Program.to(assemble(f"(({opcode[0]} {value}))"))
         await check_conditions(bt, conditions, expected_err=expected)
     @pytest.mark.anyio
     async def test_invalid_my_id(self, bt: BlockTools) -> None:
         blocks = await initial_blocks(bt)
-        coin = list(blocks[-2].get_included_reward_coins())[0]
+        coin = blocks[-2].get_included_reward_coins()[0]
         wrong_name = bytearray(coin.name())
         wrong_name[-1] ^= 1
-        conditions = Program.to(
-            assemble(
-                f"(({ConditionOpcode.ASSERT_MY_COIN_ID[0]} 0x{wrong_name.hex()}))"
-            )  # type: ignore[no-untyped-call]
-        )
+        conditions = Program.to(assemble(f"(({ConditionOpcode.ASSERT_MY_COIN_ID[0]} 0x{wrong_name.hex()}))"))
         await check_conditions(bt, conditions, expected_err=Err.ASSERT_MY_COIN_ID_FAILED)
     @pytest.mark.anyio
     async def test_valid_my_id(self, bt: BlockTools) -> None:
         blocks = await initial_blocks(bt)
-        coin = list(blocks[-2].get_included_reward_coins())[0]
-        conditions = Program.to(
-            assemble(
-                f"(({ConditionOpcode.ASSERT_MY_COIN_ID[0]} 0x{coin.name().hex()}))"
-            )  # type: ignore[no-untyped-call]
-        )
+        coin = blocks[-2].get_included_reward_coins()[0]
-        conditions = Program.to(
-            assemble(
-                f"(({ConditionOpcode.ASSERT_MY_COIN_ID[0]} 0x{coin.name().hex()}))"
-            )  # type: ignore[no-untyped-call]
-        )
+        conditions = Program.to(assemble(f"(({ConditionOpcode.ASSERT_MY_COIN_ID[0]} 0x{coin.name().hex()}))"))
         await check_conditions(bt, conditions)
     @pytest.mark.anyio
     async def test_invalid_coin_announcement(self, bt: BlockTools) -> None:
         blocks = await initial_blocks(bt)
-        coin = list(blocks[-2].get_included_reward_coins())[0]
+        coin = blocks[-2].get_included_reward_coins()[0]
         announce = AssertCoinAnnouncement(asserted_id=coin.name(), asserted_msg=b"test_bad")
         conditions = Program.to(
-            assemble(  # type: ignore[no-untyped-call]
+            assemble(
                 f"(({ConditionOpcode.CREATE_COIN_ANNOUNCEMENT[0]} 'test')"
                 f"({ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT[0]} 0x{announce.msg_calc.hex()}))"
-            )  # type: ignore[no-untyped-call]
+            )
         )
         await check_conditions(bt, conditions, expected_err=Err.ASSERT_ANNOUNCE_CONSUMED_FAILED)
     @pytest.mark.anyio
     async def test_valid_coin_announcement(self, bt: BlockTools) -> None:
         blocks = await initial_blocks(bt)
-        coin = list(blocks[-2].get_included_reward_coins())[0]
+        coin = blocks[-2].get_included_reward_coins()[0]
         announce = AssertCoinAnnouncement(asserted_id=coin.name(), asserted_msg=b"test")
         conditions = Program.to(
-            assemble(  # type: ignore[no-untyped-call]
+            assemble(
                 f"(({ConditionOpcode.CREATE_COIN_ANNOUNCEMENT[0]} 'test')"
                 f"({ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT[0]} 0x{announce.msg_calc.hex()}))"
-            )  # type: ignore[no-untyped-call]
+            )
         )
         await check_conditions(bt, conditions)
         @@@ -324,10 -332,10 +316,10 @@@
     async def test_invalid_puzzle_announcement(self, bt: BlockTools) -> None:
         announce = AssertPuzzleAnnouncement(asserted_ph=EASY_PUZZLE_HASH, asserted_msg=b"test_bad")
         conditions = Program.to(
-            assemble(  # type: ignore[no-untyped-call]
+            assemble(
                 f"(({ConditionOpcode.CREATE_PUZZLE_ANNOUNCEMENT[0]} 'test')"
                 f"({ConditionOpcode.ASSERT_PUZZLE_ANNOUNCEMENT[0]} 0x{announce.msg_calc.hex()}))"
-            )  # type: ignore[no-untyped-call]
+            )
         )
         await check_conditions(bt, conditions, expected_err=Err.ASSERT_ANNOUNCE_CONSUMED_FAILED)
         @@@ -335,10 -343,10 +327,10 @@@
     async def test_valid_puzzle_announcement(self, bt: BlockTools) -> None:
         announce = AssertPuzzleAnnouncement(asserted_ph=EASY_PUZZLE_HASH, asserted_msg=b"test")
         conditions = Program.to(
-            assemble(  # type: ignore[no-untyped-call]
+            assemble(
                 f"(({ConditionOpcode.CREATE_PUZZLE_ANNOUNCEMENT[0]} 'test')"
                 f"({ConditionOpcode.ASSERT_PUZZLE_ANNOUNCEMENT[0]} 0x{announce.msg_calc.hex()}))"
-            )  # type: ignore[no-untyped-call]
+            )
         )
         await check_conditions(bt, conditions)
         @@@ -387,7 -400,7 +379,7 @@@
         conditions = b""
         if prefix != "":
-            conditions += b"\xff" + assemble(prefix).as_bin()  # type: ignore[no-untyped-call]
+            conditions += b"\xff" + assemble(prefix).as_bin()
         cond = condition.format(
             coin="0x" + coin.name().hex(),
         @@@ -396,7 -409,7 +388,7 @@@
             pann="0x" + puzzle_announcement.msg_calc.hex(),
         )
-        conditions += (b"\xff" + assemble(cond).as_bin()) * num  # type: ignore[no-untyped-call]
+        conditions += (b"\xff" + assemble(cond).as_bin()) * num
         conditions += b"\x80"
         conditions_program = Program.from_bytes(conditions)

tests/core/full_node/test_hint_management.py CHANGED Viewed

         @@@ -17,15 -19,80 +17,15 @@@ from tests.blockchain.blockchain_test_u
 coin_ids = [std_hash(i.to_bytes(4, "big")) for i in range(10)]
 parent_ids = [std_hash(i.to_bytes(4, "big")) for i in range(10)]
 phs = [std_hash(i.to_bytes(4, "big")) for i in range(10)]
-spends: List[Spend] = [
-    Spend(
-        coin_ids[0],
-        parent_ids[0],
-        phs[0],
-        123,
-        None,
-        uint64(5),
-        None,
-        None,
-        None,
-        None,
-        [
-            (phs[2], uint64(123), b""),
-            (phs[4], uint64(3), b"1" * 32),
-        ],
-        [],
-        [],
-        [],
-        [],
-        [],
-        [],
-        [],
-        0,
-    ),
-    Spend(
-        coin_ids[2],
-        parent_ids[2],
-        phs[0],
-        123,
-        None,
-        uint64(6),
-        None,
-        None,
-        None,
-        None,
-        [
-            (phs[7], uint64(123), b""),
-            (phs[4], uint64(6), b""),
-            (phs[9], uint64(123), b"1" * 32),
-        ],
-        [],
-        [],
-        [],
-        [],
-        [],
-        [],
-        [],
-        0,
-    ),
-    Spend(
-        coin_ids[1],
-        parent_ids[1],
-        phs[7],
-        123,
-        None,
-        uint64(2),
-        None,
-        None,
-        None,
-        None,
-        [
-            (phs[5], uint64(123), b""),
-            (phs[6], uint64(5), b"1" * 3),
-        ],
-        [],
-        [],
-        [],
-        [],
-        [],
-        [],
-        [],
-        0,
-    ),
+removals = [(coin_ids[0], phs[0]), (coin_ids[2], phs[0]), (coin_ids[1], phs[7])]
+additions = [
-    (Coin(coin_ids[0], phs[2], 123), None),
-    (Coin(coin_ids[0], phs[4], 3), b"1" * 32),
-    (Coin(coin_ids[2], phs[7], 123), None),
-    (Coin(coin_ids[2], phs[4], 6), None),
-    (Coin(coin_ids[2], phs[9], 123), b"1" * 32),
-    (Coin(coin_ids[1], phs[5], 123), None),
-    (Coin(coin_ids[1], phs[6], 5), b"1" * 3),
+    (Coin(coin_ids[0], phs[2], uint64(123)), None),
+    (Coin(coin_ids[0], phs[4], uint64(3)), b"1" * 32),
+    (Coin(coin_ids[2], phs[7], uint64(123)), None),
+    (Coin(coin_ids[2], phs[4], uint64(6)), None),
+    (Coin(coin_ids[2], phs[9], uint64(123)), b"1" * 32),
+    (Coin(coin_ids[1], phs[5], uint64(123)), None),
+    (Coin(coin_ids[1], phs[6], uint64(5)), b"1" * 3),
 ]

tests/core/mempool/test_mempool.py CHANGED Viewed

         @@@ -2748,7 -2740,7 +2748,7 @@@ def rand_hash() -> bytes32
 def item_cost(cost: int, fee_rate: float) -> MempoolItem:
     fee = cost * fee_rate
-    amount = int(fee + 100)
+    amount = uint64(fee + 100)
     coin = Coin(rand_hash(), rand_hash(), amount)
     return mk_item([coin], cost=cost, fee=int(cost * fee_rate))
         @@@ -2837,7 -2824,7 +2837,7 @@@ def test_limit_expiring_transactions(he
     fee_rate = 2.7
     for cost in items:
         fee = cost * fee_rate
-        amount = int(fee + 100)
+        amount = uint64(fee + 100)
         coin = Coin(rand_hash(), rand_hash(), amount)
         if height:
             ret = mempool.add_to_pool(mk_item([coin], cost=cost, fee=int(cost * fee_rate), assert_before_height=15))

tests/core/mempool/test_mempool_manager.py CHANGED Viewed

         @@@ -133,17 -117,14 +133,22 @@@ async def instantiate_mempool_manager
     block_height: uint32 = TEST_HEIGHT,
     block_timestamp: uint64 = TEST_TIMESTAMP,
     constants: ConsensusConstants = DEFAULT_CONSTANTS,
+    max_tx_clvm_cost: Optional[uint64] = None,
 ) -> MempoolManager:
-    mempool_manager = MempoolManager(get_coin_records, constants)
-    mempool_manager = MempoolManager(get_coin_record, constants)
+    mempool_manager = MempoolManager(get_coin_records, constants, max_tx_clvm_cost=max_tx_clvm_cost)
     test_block_record = create_test_block_record(height=block_height, timestamp=block_timestamp)
     await mempool_manager.new_peak(test_block_record, None)
+    invariant_check_mempool(mempool_manager.mempool)
     return mempool_manager
-async def setup_mempool_with_coins(*, coin_amounts: List[int]) -> Tuple[MempoolManager, List[Coin]]:
+async def setup_mempool_with_coins(
-    *, coin_amounts: List[int], max_block_clvm_cost: Optional[int] = None
+    *,
+    coin_amounts: List[int],
+    max_block_clvm_cost: Optional[int] = None,
+    max_tx_clvm_cost: Optional[uint64] = None,
+    mempool_block_buffer: Optional[int] = None,
+) -> Tuple[MempoolManager, List[Coin]]:
     coins = []
     test_coin_records = {}
     for amount in coin_amounts:
         @@@ -151,19 -132,10 +156,22 @@@
         coins.append(coin)
         test_coin_records[coin.name()] = CoinRecord(coin, uint32(0), uint32(0), False, uint64(0))
-    async def get_coin_record(coin_id: bytes32) -> Optional[CoinRecord]:
-        return test_coin_records.get(coin_id)
-    mempool_manager = await instantiate_mempool_manager(get_coin_record)
+    async def get_coin_records(coin_ids: Collection[bytes32]) -> List[CoinRecord]:
+        ret: List[CoinRecord] = []
+        for name in coin_ids:
+            r = test_coin_records.get(name)
+            if r is not None:
+                ret.append(r)
+        return ret
+    constants = DEFAULT_CONSTANTS
+    if max_block_clvm_cost is not None:
-        constants = dataclasses.replace(DEFAULT_CONSTANTS, MAX_BLOCK_COST_CLVM=max_block_clvm_cost)
-    else:
-        constants = DEFAULT_CONSTANTS
-    mempool_manager = await instantiate_mempool_manager(get_coin_records, constants=constants)
+        constants = dataclasses.replace(constants, MAX_BLOCK_COST_CLVM=max_block_clvm_cost)
+    if mempool_block_buffer is not None:
+        constants = dataclasses.replace(constants, MEMPOOL_BLOCK_BUFFER=mempool_block_buffer)
+    mempool_manager = await instantiate_mempool_manager(
+        get_coin_records, constants=constants, max_tx_clvm_cost=max_tx_clvm_cost
+    )
     return (mempool_manager, coins)
         @@@ -404,13 -359,9 +412,13 @@@ def make_bundle_spends_map_and_fee
         coin_id = bytes32(spend.coin_id)
         spend_additions = []
         for puzzle_hash, amount, _ in spend.create_coin:
-            spend_additions.append(Coin(coin_id, puzzle_hash, amount))
+            spend_additions.append(Coin(coin_id, puzzle_hash, uint64(amount)))
             additions_amount += amount
-        eligibility_and_additions[coin_id] = (bool(spend.flags & ELIGIBLE_FOR_DEDUP), spend_additions)
+        eligibility_and_additions[coin_id] = EligibilityAndAdditions(
+            is_eligible_for_dedup=bool(spend.flags & ELIGIBLE_FOR_DEDUP),
+            spend_additions=spend_additions,
+            is_eligible_for_ff=bool(spend.flags & ELIGIBLE_FOR_FF),
+        )
     for coin_spend in spend_bundle.coin_spends:
         coin_id = coin_spend.coin.name()
         removals_amount += coin_spend.coin.amount
         @@@ -681,7 -625,7 +689,7 @@@ async def test_ephemeral_timelock
     )
     conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1]]
-    created_coin = Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, 1)
+    created_coin = Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, uint64(1))
     sb1 = spend_bundle_from_conditions(conditions)
     sb2 = spend_bundle_from_conditions([[opcode, lock_value]], created_coin)
     # sb spends TEST_COIN and creates created_coin which gets spent too
         @@@ -739,7 -683,7 +747,7 @@@ def mk_item
 def make_test_coins() -> List[Coin]:
     ret: List[Coin] = []
     for i in range(5):
-        ret.append(Coin(height_hash(i), height_hash(i + 100), i * 100))
+        ret.append(Coin(height_hash(i), height_hash(i + 100), uint64(i * 100)))
     return ret
         @@@ -992,8 -928,8 +1000,8 @@@ async def test_create_bundle_from_mempo
             assert result[1] == MempoolInclusionStatus.SUCCESS
     mempool_manager, coins = await setup_mempool_with_coins(coin_amounts=list(range(2000000000, 2000002200)))
-    high_rate_spends = await make_coin_spends(coins[0:2000])
-    low_rate_spends = await make_coin_spends(coins[2000:2100], high_fees=False)
+    high_rate_spends = await make_coin_spends(coins[0:2200])
+    low_rate_spends = await make_coin_spends(coins[2200:2400], high_fees=False)
     spends = low_rate_spends + high_rate_spends if reverse_tx_order else high_rate_spends + low_rate_spends
     await send_spends_to_mempool(spends)
     assert mempool_manager.peak is not None
         @@@ -1022,71 -947,30 +1030,74 @@@ async def test_create_bundle_from_mempo
     async def make_and_send_big_cost_sb(coin: Coin) -> None:
         conditions = []
         g1 = G1Element()
-        for _ in range(120):
-        for _ in range(2436):
+        for _ in range(144):
             conditions.append([ConditionOpcode.AGG_SIG_UNSAFE, g1, IDENTITY_PUZZLE_HASH])
-        conditions.append([ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coin.amount - 1])
+        conditions.append([ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coin.amount - 10_000_000])
         # Create a spend bundle with a big enough cost that gets it close to the limit
         _, _, res = await generate_and_add_spendbundle(mempool_manager, conditions, coin)
         assert res[1] == MempoolInclusionStatus.SUCCESS
-    mempool_manager, coins = await setup_mempool_with_coins(coin_amounts=[1000000000, 1000000001])
-    # Create a spend bundle with a big enough cost that gets it close to the limit
-    await make_and_send_big_cost_sb(coins[0])
-    # Create a second spend bundle with a relatively smaller cost.
-    # Combined with the first spend bundle, we'd exceed the maximum block clvm cost
-    conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coins[1].amount - 2]]
-    sb2, _, res = await generate_and_add_spendbundle(mempool_manager, conditions, coins[1])
+    mempool_manager, coins = await setup_mempool_with_coins(
-        coin_amounts=list(range(1_000_000_000, 1_000_000_030)), max_block_clvm_cost=550_000_000
+        coin_amounts=list(range(1_000_000_000, 1_000_000_030)),
+        max_block_clvm_cost=550_000_000,
+        max_tx_clvm_cost=uint64(550_000_000 * 0.6),
+        mempool_block_buffer=20,
+    )
+    # Create the spend bundles with a big enough cost that they get close to the limit
+    for i in range(num_skipped_items):
+        await make_and_send_big_cost_sb(coins[i])
+    # Create a spend bundle with a relatively smaller cost.
+    # Combined with a big cost spend bundle, we'd exceed the maximum block clvm cost
+    sb2_coin = coins[num_skipped_items]
+    conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, sb2_coin.amount - 200_000]]
+    sb2, _, res = await generate_and_add_spendbundle(mempool_manager, conditions, sb2_coin)
     assert res[1] == MempoolInclusionStatus.SUCCESS
-    sb2_addition = Coin(sb2_coin.name(), IDENTITY_PUZZLE_HASH, sb2_coin.amount - 200_000)
+    sb2_addition = Coin(sb2_coin.name(), IDENTITY_PUZZLE_HASH, uint64(sb2_coin.amount - 200_000))
+    # Create 4 extra spend bundles with smaller FPC and smaller costs
+    extra_sbs = []
+    extra_additions = []
+    for i in range(num_skipped_items + 1, num_skipped_items + 5):
+        conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coins[i].amount - 30_000]]
+        # Make the first of these without eligible coins
+        if i == num_skipped_items + 1:
+            conditions.append([ConditionOpcode.AGG_SIG_UNSAFE, G1Element(), IDENTITY_PUZZLE_HASH])
+        sb, _, res = await generate_and_add_spendbundle(mempool_manager, conditions, coins[i])
+        extra_sbs.append(sb)
-        coin = Coin(coins[i].name(), IDENTITY_PUZZLE_HASH, coins[i].amount - 30_000)
+        coin = Coin(coins[i].name(), IDENTITY_PUZZLE_HASH, uint64(coins[i].amount - 30_000))
+        extra_additions.append(coin)
+        assert res[1] == MempoolInclusionStatus.SUCCESS
     assert mempool_manager.peak is not None
-    result = mempool_manager.create_bundle_from_mempool(mempool_manager.peak.header_hash)
+    caplog.set_level(logging.DEBUG)
+    result = await mempool_manager.create_bundle_from_mempool(
+        mempool_manager.peak.header_hash, get_unspent_lineage_info_for_puzzle_hash
+    )
     assert result is not None
     agg, additions = result
-    # The second spend bundle has a higher FPC so it should get picked first
-    assert agg == sb2
-    # The first spend bundle hits the maximum block clvm cost and gets skipped
-    assert additions == [Coin(coins[1].name(), IDENTITY_PUZZLE_HASH, coins[1].amount - 2)]
-    assert agg.removals() == [coins[1]]
+    skipped_due_to_eligible_coins = sum(
+        1
+        for line in caplog.text.split("\n")
+        if "DEBUG Exception while checking a mempool item for deduplication: Skipping transaction with eligible coin(s)"
+        in line
+    )
+    if num_skipped_items == PRIORITY_TX_THRESHOLD:
+        # We skipped enough big cost items to reach `PRIORITY_TX_THRESHOLD`,
+        # so the first from the extra 4 (the one without eligible coins) went in,
+        # and the other 3 were skipped (they have eligible coins)
+        assert skipped_due_to_eligible_coins == 3
+        assert agg == SpendBundle.aggregate([sb2, extra_sbs[0]])
+        assert additions == [sb2_addition, extra_additions[0]]
+        assert agg.removals() == [sb2_coin, coins[num_skipped_items + 1]]
+    elif num_skipped_items == MAX_SKIPPED_ITEMS:
+        # We skipped enough big cost items to trigger `MAX_SKIPPED_ITEMS` so
+        # we didn't process any of the extra items
+        assert skipped_due_to_eligible_coins == 0
+        assert agg == SpendBundle.aggregate([sb2])
+        assert additions == [sb2_addition]
+        assert agg.removals() == [sb2_coin]
+    else:
+        raise ValueError("num_skipped_items must be PRIORITY_TX_THRESHOLD or MAX_SKIPPED_ITEMS")  # pragma: no cover
 @pytest.mark.parametrize(
         @@@ -1345,7 -1221,7 +1356,7 @@@ def test_dedup_info_nothing_to_do() ->
     )
     assert unique_coin_spends == sb.coin_spends
     assert cost_saving == 0
-    assert unique_additions == [Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, 1)]
+    assert unique_additions == [Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, uint64(1))]
     assert eligible_coin_spends == EligibleCoinSpends()
         @@@ -1366,8 -1241,8 +1377,8 @@@ def test_dedup_info_eligible_1st_time(
     assert unique_coin_spends == sb.coin_spends
     assert cost_saving == 0
     assert set(unique_additions) == {
-        Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, 1),
-        Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, 2),
+        Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, uint64(1)),
+        Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, uint64(2)),
     }
     assert eligible_coin_spends == EligibleCoinSpends({TEST_COIN_ID: DedupCoinSpend(solution=solution, cost=None)})
         @@@ -1412,7 -1285,7 +1423,7 @@@ def test_dedup_info_eligible_2nd_time_a
     assert unique_coin_spends == sb2.coin_spends
     saved_cost = uint64(3600044)
     assert cost_saving == saved_cost
-    assert unique_additions == [Coin(TEST_COIN_ID2, IDENTITY_PUZZLE_HASH, 3)]
+    assert unique_additions == [Coin(TEST_COIN_ID2, IDENTITY_PUZZLE_HASH, uint64(3))]
     # The coin we encountered a second time has its cost and additions properly updated
     # The coin we encountered for the first time gets cost None and an empty set of additions
     expected_eligible_spends = EligibleCoinSpends(
         @@@ -1456,7 -1328,7 +1467,7 @@@ def test_dedup_info_eligible_3rd_time_a
     assert unique_coin_spends == sb3.coin_spends
     saved_cost2 = uint64(1800044)
     assert cost_saving == saved_cost + saved_cost2
-    assert unique_additions == [Coin(TEST_COIN_ID3, IDENTITY_PUZZLE_HASH, 4)]
+    assert unique_additions == [Coin(TEST_COIN_ID3, IDENTITY_PUZZLE_HASH, uint64(4))]
     expected_eligible_spends = EligibleCoinSpends(
         {
             TEST_COIN_ID: DedupCoinSpend(initial_solution, saved_cost),
         @@@ -1476,7 -1348,7 +1487,7 @@@ async def test_coin_spending_different_
     the reorg code paths
     """
     new_height = uint32(TEST_HEIGHT + new_height_step)
-    coin = Coin(IDENTITY_PUZZLE_HASH, IDENTITY_PUZZLE_HASH, 100)
+    coin = Coin(IDENTITY_PUZZLE_HASH, IDENTITY_PUZZLE_HASH, uint64(100))
     coin_id = coin.name()
     test_coin_records = {coin_id: CoinRecord(coin, uint32(0), uint32(0), False, uint64(0))}

tests/core/mempool/test_singleton_fast_forward.py CHANGED Viewed

         @@@ -1,554 -1,0 +1,554 @@@
+from __future__ import annotations
+import dataclasses
+from typing import Any, Dict, List, Optional, Tuple
+import pytest
+from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
+from more_itertools import partition
+from chia.clvm.spend_sim import SimClient, SpendSim, sim_and_client
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_spend import CoinSpend, make_spend
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.types.eligible_coin_spends import EligibleCoinSpends, UnspentLineageInfo, perform_the_fast_forward
+from chia.types.internal_mempool_item import InternalMempoolItem
+from chia.types.mempool_inclusion_status import MempoolInclusionStatus
+from chia.types.mempool_item import BundleCoinSpend
+from chia.types.spend_bundle import SpendBundle
+from chia.util.errors import Err
+from chia.util.ints import uint64
+from chia.wallet.puzzles import p2_conditions, p2_delegated_puzzle_or_hidden_puzzle
+from chia.wallet.puzzles import singleton_top_layer_v1_1 as singleton_top_layer
+from tests.clvm.test_puzzles import public_key_for_index, secret_exponent_for_index
+from tests.core.mempool.test_mempool_manager import (
+    IDENTITY_PUZZLE,
+    IDENTITY_PUZZLE_HASH,
+    TEST_COIN,
+    TEST_COIN_ID,
+    TEST_HEIGHT,
+    mempool_item_from_spendbundle,
+    spend_bundle_from_conditions,
+)
+from tests.util.key_tool import KeyTool
+@pytest.mark.anyio
+async def test_process_fast_forward_spends_nothing_to_do() -> None:
+    """
+    This tests the case when we don't have an eligible coin, so there is
+    nothing to fast forward and the item remains unchanged
+    """
+    async def get_unspent_lineage_info_for_puzzle_hash(_: bytes32) -> Optional[UnspentLineageInfo]:
+        assert False  # pragma: no cover
+    conditions = [[ConditionOpcode.AGG_SIG_UNSAFE, G1Element(), IDENTITY_PUZZLE_HASH]]
+    sb = spend_bundle_from_conditions(conditions, TEST_COIN)
+    item = mempool_item_from_spendbundle(sb)
+    # This coin is not eligible for fast forward
+    assert item.bundle_coin_spends[TEST_COIN_ID].eligible_for_fast_forward is False
+    internal_mempool_item = InternalMempoolItem(
+        sb, item.npc_result, item.height_added_to_mempool, item.bundle_coin_spends
+    )
+    original_version = dataclasses.replace(internal_mempool_item)
+    eligible_coin_spends = EligibleCoinSpends()
+    await eligible_coin_spends.process_fast_forward_spends(
+        mempool_item=internal_mempool_item,
+        get_unspent_lineage_info_for_puzzle_hash=get_unspent_lineage_info_for_puzzle_hash,
+        height=TEST_HEIGHT,
+        constants=DEFAULT_CONSTANTS,
+    )
+    assert eligible_coin_spends == EligibleCoinSpends()
+    assert internal_mempool_item == original_version
+@pytest.mark.anyio
+async def test_process_fast_forward_spends_unknown_ff() -> None:
+    """
+    This tests the case when we process for the first time but we are unable
+    to lookup the latest version from the DB
+    """
+    async def get_unspent_lineage_info_for_puzzle_hash(puzzle_hash: bytes32) -> Optional[UnspentLineageInfo]:
+        if puzzle_hash == IDENTITY_PUZZLE_HASH:
+            return None
+        assert False  # pragma: no cover
-    test_coin = Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, 1)
+    test_coin = Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, uint64(1))
+    conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1]]
+    sb = spend_bundle_from_conditions(conditions, test_coin)
+    item = mempool_item_from_spendbundle(sb)
+    # The coin is eligible for fast forward
+    assert item.bundle_coin_spends[test_coin.name()].eligible_for_fast_forward is True
+    internal_mempool_item = InternalMempoolItem(
+        sb, item.npc_result, item.height_added_to_mempool, item.bundle_coin_spends
+    )
+    eligible_coin_spends = EligibleCoinSpends()
+    # We have no fast forward records yet, so we'll process this coin for the
+    # first time here, but the DB lookup will return None
+    with pytest.raises(ValueError, match="Cannot proceed with singleton spend fast forward."):
+        await eligible_coin_spends.process_fast_forward_spends(
+            mempool_item=internal_mempool_item,
+            get_unspent_lineage_info_for_puzzle_hash=get_unspent_lineage_info_for_puzzle_hash,
+            height=TEST_HEIGHT,
+            constants=DEFAULT_CONSTANTS,
+        )
+@pytest.mark.anyio
+async def test_process_fast_forward_spends_latest_unspent() -> None:
+    """
+    This tests the case when we are the latest singleton version already, so
+    we don't need to fast forward, we just need to set the next version from
+    our additions to chain ff spends.
+    """
-    test_amount = 3
+    test_amount = uint64(3)
+    test_coin = Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, test_amount)
+    test_unspent_lineage_info = UnspentLineageInfo(
+        coin_id=test_coin.name(),
+        coin_amount=test_coin.amount,
+        parent_id=test_coin.parent_coin_info,
+        parent_amount=test_coin.amount,
+        parent_parent_id=TEST_COIN_ID,
+    )
+    async def get_unspent_lineage_info_for_puzzle_hash(puzzle_hash: bytes32) -> Optional[UnspentLineageInfo]:
+        if puzzle_hash == IDENTITY_PUZZLE_HASH:
+            return test_unspent_lineage_info
+        assert False  # pragma: no cover
+    # At this point, spends are considered *potentially* eligible for singleton
+    # fast forward mainly when their amount is even and they don't have conditions
+    # that disqualify them
+    conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, test_amount - 2]]
+    sb = spend_bundle_from_conditions(conditions, test_coin)
+    item = mempool_item_from_spendbundle(sb)
+    assert item.bundle_coin_spends[test_coin.name()].eligible_for_fast_forward is True
+    internal_mempool_item = InternalMempoolItem(
+        sb, item.npc_result, item.height_added_to_mempool, item.bundle_coin_spends
+    )
+    original_version = dataclasses.replace(internal_mempool_item)
+    eligible_coin_spends = EligibleCoinSpends()
+    await eligible_coin_spends.process_fast_forward_spends(
+        mempool_item=internal_mempool_item,
+        get_unspent_lineage_info_for_puzzle_hash=get_unspent_lineage_info_for_puzzle_hash,
+        height=TEST_HEIGHT,
+        constants=DEFAULT_CONSTANTS,
+    )
+    child_coin = item.bundle_coin_spends[test_coin.name()].additions[0]
+    expected_fast_forward_spends = {
+        IDENTITY_PUZZLE_HASH: UnspentLineageInfo(
+            coin_id=child_coin.name(),
+            coin_amount=child_coin.amount,
+            parent_id=test_coin.name(),
+            parent_amount=test_coin.amount,
+            parent_parent_id=test_coin.parent_coin_info,
+        )
+    }
+    # We have set the next version from our additions to chain ff spends
+    assert eligible_coin_spends.fast_forward_spends == expected_fast_forward_spends
+    # We didn't need to fast forward the item so it stays as is
+    assert internal_mempool_item == original_version
+def test_perform_the_fast_forward() -> None:
+    """
+    This test attempts to spend a coin that is already spent and the current
+    unspent version is its grandchild. We fast forward the test coin spend into
+    a spend of that latest unspent
+    """
+    test_parent_id = bytes32.from_hexstr("0x039759eda861cd44c0af6c9501300f66fe4f5de144b8ae4fc4e8da35701f38ac")
+    test_ph = bytes32.from_hexstr("0x9ae0917f3ca301f934468ec60412904c0a88b232aeabf220c01ef53054e0281a")
-    test_amount = 1337
+    test_amount = uint64(1337)
+    test_coin = Coin(test_parent_id, test_ph, test_amount)
+    test_child_coin = Coin(test_coin.name(), test_ph, test_amount)
+    latest_unspent_coin = Coin(test_child_coin.name(), test_ph, test_amount)
+    # This spend setup makes us eligible for fast forward so that we perform a
+    # meaningful fast forward on the rust side. It was generated using the
+    # singleton/child/grandchild dynamics that we have in
+    # `test_singleton_fast_forward_different_block` to get a realistic test case
+    test_puzzle_reveal = SerializedProgram.fromhex(
+        "ff02ffff01ff02ffff01ff02ffff03ffff18ff2fff3480ffff01ff04ffff04ff20ffff04ff2fff808080ffff04ffff02ff3effff04ff0"
+        "2ffff04ff05ffff04ffff02ff2affff04ff02ffff04ff27ffff04ffff02ffff03ff77ffff01ff02ff36ffff04ff02ffff04ff09ffff04"
+        "ff57ffff04ffff02ff2effff04ff02ffff04ff05ff80808080ff808080808080ffff011d80ff0180ffff04ffff02ffff03ff77ffff018"
+        "1b7ffff015780ff0180ff808080808080ffff04ff77ff808080808080ffff02ff3affff04ff02ffff04ff05ffff04ffff02ff0bff5f80"
+        "ffff01ff8080808080808080ffff01ff088080ff0180ffff04ffff01ffffffff4947ff0233ffff0401ff0102ffffff20ff02ffff03ff0"
+        "5ffff01ff02ff32ffff04ff02ffff04ff0dffff04ffff0bff3cffff0bff34ff2480ffff0bff3cffff0bff3cffff0bff34ff2c80ff0980"
+        "ffff0bff3cff0bffff0bff34ff8080808080ff8080808080ffff010b80ff0180ffff02ffff03ffff22ffff09ffff0dff0580ff2280fff"
+        "f09ffff0dff0b80ff2280ffff15ff17ffff0181ff8080ffff01ff0bff05ff0bff1780ffff01ff088080ff0180ff02ffff03ff0bffff01"
+        "ff02ffff03ffff02ff26ffff04ff02ffff04ff13ff80808080ffff01ff02ffff03ffff20ff1780ffff01ff02ffff03ffff09ff81b3fff"
+        "f01818f80ffff01ff02ff3affff04ff02ffff04ff05ffff04ff1bffff04ff34ff808080808080ffff01ff04ffff04ff23ffff04ffff02"
+        "ff36ffff04ff02ffff04ff09ffff04ff53ffff04ffff02ff2effff04ff02ffff04ff05ff80808080ff808080808080ff738080ffff02f"
+        "f3affff04ff02ffff04ff05ffff04ff1bffff04ff34ff8080808080808080ff0180ffff01ff088080ff0180ffff01ff04ff13ffff02ff"
+        "3affff04ff02ffff04ff05ffff04ff1bffff04ff17ff8080808080808080ff0180ffff01ff02ffff03ff17ff80ffff01ff088080ff018"
+        "080ff0180ffffff02ffff03ffff09ff09ff3880ffff01ff02ffff03ffff18ff2dffff010180ffff01ff0101ff8080ff0180ff8080ff01"
+        "80ff0bff3cffff0bff34ff2880ffff0bff3cffff0bff3cffff0bff34ff2c80ff0580ffff0bff3cffff02ff32ffff04ff02ffff04ff07f"
+        "fff04ffff0bff34ff3480ff8080808080ffff0bff34ff8080808080ffff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff2eff"
+        "ff04ff02ffff04ff09ff80808080ffff02ff2effff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff02fff"
+        "f03ffff21ff17ffff09ff0bff158080ffff01ff04ff30ffff04ff0bff808080ffff01ff088080ff0180ff018080ffff04ffff01ffa07f"
+        "aa3253bfddd1e0decb0906b2dc6247bbc4cf608f58345d173adb63e8b47c9fffa030d940e53ed5b56fee3ae46ba5f4e59da5e2cc9242f"
+        "6e482fe1f1e4d9a463639a0eff07522495060c066f66f32acc2a77e3a3e737aca8baea4d1a64ea4cdc13da9ffff04ffff010dff018080"
+        "80"
+    )
+    test_solution = SerializedProgram.fromhex(
+        "ffffa030d940e53ed5b56fee3ae46ba5f4e59da5e2cc9242f6e482fe1f1e4d9a463639ffa0c7b89cfb9abf2c4cb212a4840b37d762f4c"
+        "880b8517b0dadb0c310ded24dd86dff82053980ff820539ffff80ffff01ffff33ffa0c7b89cfb9abf2c4cb212a4840b37d762f4c880b8"
+        "517b0dadb0c310ded24dd86dff8205398080ff808080"
+    )
+    test_coin_spend = CoinSpend(test_coin, test_puzzle_reveal, test_solution)
+    test_spend_data = BundleCoinSpend(test_coin_spend, False, True, [test_child_coin])
+    test_unspent_lineage_info = UnspentLineageInfo(
+        coin_id=latest_unspent_coin.name(),
+        coin_amount=latest_unspent_coin.amount,
+        parent_id=latest_unspent_coin.parent_coin_info,
+        parent_amount=test_child_coin.amount,
+        parent_parent_id=test_child_coin.parent_coin_info,
+    )
+    # Start from a fresh state of fast forward spends
+    fast_forward_spends: Dict[bytes32, UnspentLineageInfo] = {}
+    # Perform the fast forward on the test coin (the grandparent)
+    new_coin_spend, patched_additions = perform_the_fast_forward(
+        test_unspent_lineage_info, test_spend_data, fast_forward_spends
+    )
+    # Make sure the new coin we got is the grandchild (latest unspent version)
+    assert new_coin_spend.coin == latest_unspent_coin
+    # Make sure the puzzle reveal is intact
+    assert new_coin_spend.puzzle_reveal == test_coin_spend.puzzle_reveal
+    # Make sure the solution got patched
+    assert new_coin_spend.solution != test_coin_spend.solution
+    # Make sure the additions got patched
+    expected_child_coin = Coin(latest_unspent_coin.name(), test_ph, test_amount)
+    assert patched_additions == [expected_child_coin]
+    # Make sure the new fast forward state got updated with the latest unspent
+    # becoming the new child, with its parent being the version we just spent
+    # (previously latest unspent)
+    expected_unspent_lineage_info = UnspentLineageInfo(
+        coin_id=expected_child_coin.name(),
+        coin_amount=expected_child_coin.amount,
+        parent_id=latest_unspent_coin.name(),
+        parent_amount=latest_unspent_coin.amount,
+        parent_parent_id=latest_unspent_coin.parent_coin_info,
+    )
+    assert fast_forward_spends == {test_ph: expected_unspent_lineage_info}
+def sign_delegated_puz(del_puz: Program, coin: Coin) -> G2Element:
+    synthetic_secret_key: PrivateKey = p2_delegated_puzzle_or_hidden_puzzle.calculate_synthetic_secret_key(
+        PrivateKey.from_bytes(secret_exponent_for_index(1).to_bytes(32, "big")),
+        p2_delegated_puzzle_or_hidden_puzzle.DEFAULT_HIDDEN_PUZZLE_HASH,
+    )
+    return AugSchemeMPL.sign(
+        synthetic_secret_key, (del_puz.get_tree_hash() + coin.name() + DEFAULT_CONSTANTS.AGG_SIG_ME_ADDITIONAL_DATA)
+    )
+async def make_and_send_spend_bundle(
+    sim: SpendSim,
+    sim_client: SimClient,
+    coin_spends: List[CoinSpend],
+    is_eligible_for_ff: bool = True,
+    is_launcher_coin: bool = False,
+    signing_puzzle: Optional[Program] = None,
+    signing_coin: Optional[Coin] = None,
+) -> Tuple[MempoolInclusionStatus, Optional[Err]]:
+    if is_launcher_coin or not is_eligible_for_ff:
+        assert signing_puzzle is not None
+        assert signing_coin is not None
+        signature = sign_delegated_puz(signing_puzzle, signing_coin)
+    else:
+        signature = G2Element()
+    spend_bundle = SpendBundle(coin_spends, signature)
+    status, error = await sim_client.push_tx(spend_bundle)
+    if error is None:
+        await sim.farm_block()
+    return status, error
+async def get_singleton_and_remaining_coins(sim: SpendSim) -> Tuple[Coin, List[Coin]]:
+    coins = await sim.all_non_reward_coins()
+    singletons, remaining_coins = partition(lambda coin: coin.amount % 2 == 0, coins)
+    singletons_list = list(singletons)
+    assert len(singletons_list) == 1
+    return singletons_list[0], list(remaining_coins)
+def make_singleton_coin_spend(
+    parent_coin_spend: CoinSpend,
+    coin_to_spend: Coin,
+    inner_puzzle: Program,
+    inner_conditions: List[List[Any]],
+    is_eve_spend: bool = False,
+) -> Tuple[CoinSpend, Program]:
+    lineage_proof = singleton_top_layer.lineage_proof_for_coinsol(parent_coin_spend)
+    delegated_puzzle = Program.to((1, inner_conditions))
+    inner_solution = Program.to([[], delegated_puzzle, []])
+    solution = singleton_top_layer.solution_for_singleton(lineage_proof, uint64(coin_to_spend.amount), inner_solution)
+    if is_eve_spend:
+        # Parent here is the launcher coin
+        puzzle_reveal = SerializedProgram.from_program(
+            singleton_top_layer.puzzle_for_singleton(parent_coin_spend.coin.name(), inner_puzzle)
+        )
+    else:
+        puzzle_reveal = parent_coin_spend.puzzle_reveal
+    return make_spend(coin_to_spend, puzzle_reveal, solution), delegated_puzzle
+async def prepare_singleton_eve(
+    sim: SpendSim, sim_client: SimClient, is_eligible_for_ff: bool, start_amount: uint64, singleton_amount: uint64
+) -> Tuple[Program, CoinSpend, Program]:
+    # Generate starting info
+    key_lookup = KeyTool()
+    pk = G1Element.from_bytes(public_key_for_index(1, key_lookup))
+    starting_puzzle = p2_delegated_puzzle_or_hidden_puzzle.puzzle_for_pk(pk)
+    if is_eligible_for_ff:
+        # This program allows us to control conditions through solutions
+        inner_puzzle = Program.to(13)
+    else:
+        inner_puzzle = starting_puzzle
+    inner_puzzle_hash = inner_puzzle.get_tree_hash()
+    # Get our starting standard coin created
+    await sim.farm_block(starting_puzzle.get_tree_hash())
+    records = await sim_client.get_coin_records_by_puzzle_hash(starting_puzzle.get_tree_hash())
+    starting_coin = records[0].coin
+    # Launching
+    conditions, launcher_coin_spend = singleton_top_layer.launch_conditions_and_coinsol(
+        coin=starting_coin, inner_puzzle=inner_puzzle, comment=[], amount=start_amount
+    )
+    # Keep a remaining coin with an even amount
+    conditions.append(
+        Program.to([ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, starting_coin.amount - start_amount - 1])
+    )
+    # Create a solution for standard transaction
+    delegated_puzzle = p2_conditions.puzzle_for_conditions(conditions)
+    full_solution = p2_delegated_puzzle_or_hidden_puzzle.solution_for_conditions(conditions)
+    starting_coin_spend = make_spend(starting_coin, starting_puzzle, full_solution)
+    await make_and_send_spend_bundle(
+        sim,
+        sim_client,
+        [starting_coin_spend, launcher_coin_spend],
+        is_eligible_for_ff,
+        is_launcher_coin=True,
+        signing_puzzle=delegated_puzzle,
+        signing_coin=starting_coin,
+    )
+    eve_coin, _ = await get_singleton_and_remaining_coins(sim)
+    inner_conditions = [[ConditionOpcode.CREATE_COIN, inner_puzzle_hash, singleton_amount]]
+    eve_coin_spend, eve_signing_puzzle = make_singleton_coin_spend(
+        parent_coin_spend=launcher_coin_spend,
+        coin_to_spend=eve_coin,
+        inner_puzzle=inner_puzzle,
+        inner_conditions=inner_conditions,
+        is_eve_spend=True,
+    )
+    return inner_puzzle, eve_coin_spend, eve_signing_puzzle
+async def prepare_and_test_singleton(
+    sim: SpendSim, sim_client: SimClient, is_eligible_for_ff: bool, start_amount: uint64, singleton_amount: uint64
+) -> Tuple[Coin, CoinSpend, Program, Coin]:
+    inner_puzzle, eve_coin_spend, eve_signing_puzzle = await prepare_singleton_eve(
+        sim, sim_client, is_eligible_for_ff, start_amount, singleton_amount
+    )
+    # At this point we don't have any unspent singleton
+    singleton_puzzle_hash = eve_coin_spend.coin.puzzle_hash
+    unspent_lineage_info = await sim_client.service.coin_store.get_unspent_lineage_info_for_puzzle_hash(
+        singleton_puzzle_hash
+    )
+    assert unspent_lineage_info is None
+    eve_coin = eve_coin_spend.coin
+    await make_and_send_spend_bundle(
+        sim, sim_client, [eve_coin_spend], is_eligible_for_ff, signing_puzzle=eve_signing_puzzle, signing_coin=eve_coin
+    )
+    # Now we spent eve and we have an unspent singleton that we can test with
+    singleton, [remaining_coin] = await get_singleton_and_remaining_coins(sim)
+    assert singleton.amount == singleton_amount
+    singleton_puzzle_hash = eve_coin.puzzle_hash
+    unspent_lineage_info = await sim_client.service.coin_store.get_unspent_lineage_info_for_puzzle_hash(
+        singleton_puzzle_hash
+    )
+    assert unspent_lineage_info == UnspentLineageInfo(
+        coin_id=singleton.name(),
+        coin_amount=singleton.amount,
+        parent_id=eve_coin.name(),
+        parent_amount=eve_coin.amount,
+        parent_parent_id=eve_coin.parent_coin_info,
+    )
+    return singleton, eve_coin_spend, inner_puzzle, remaining_coin
+@pytest.mark.anyio
+@pytest.mark.parametrize("is_eligible_for_ff", [True, False])
+async def test_singleton_fast_forward_different_block(is_eligible_for_ff: bool) -> None:
+    """
+    This tests uses the `is_eligible_for_ff` parameter to cover both when a
+    singleton is eligible for fast forward and when it's not, as we attempt to
+    spend an earlier version of it, in a different block, and watch it either
+    get properly fast forwarded to the latest unspent (when it's eligible) or
+    get correctly rejected as a double spend (when it's not eligible)
+    """
+    START_AMOUNT = uint64(1337)
+    # We're decrementing the next iteration's amount for testing purposes
+    SINGLETON_AMOUNT = uint64(1335)
+    # We're incrementing the next iteration's amount for testing purposes
+    SINGLETON_CHILD_AMOUNT = uint64(1339)
+    async with sim_and_client() as (sim, sim_client):
+        singleton, eve_coin_spend, inner_puzzle, remaining_coin = await prepare_and_test_singleton(
+            sim, sim_client, is_eligible_for_ff, START_AMOUNT, SINGLETON_AMOUNT
+        )
+        # Let's spend this first version, to create a bigger singleton child
+        singleton_puzzle_hash = eve_coin_spend.coin.puzzle_hash
+        inner_puzzle_hash = inner_puzzle.get_tree_hash()
+        inner_conditions = [
+            [ConditionOpcode.AGG_SIG_UNSAFE, G1Element(), IDENTITY_PUZZLE_HASH],
+            [ConditionOpcode.CREATE_COIN, inner_puzzle_hash, SINGLETON_CHILD_AMOUNT],
+        ]
+        singleton_coin_spend, singleton_signing_puzzle = make_singleton_coin_spend(
+            eve_coin_spend, singleton, inner_puzzle, inner_conditions
+        )
+        # Spend also a remaining coin for balance, as we're increasing the singleton amount
+        diff_to_balance = SINGLETON_CHILD_AMOUNT - SINGLETON_AMOUNT
+        remaining_spend_solution = SerializedProgram.from_program(
+            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount - diff_to_balance]])
+        )
+        remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
+        await make_and_send_spend_bundle(
+            sim,
+            sim_client,
+            [remaining_coin_spend, singleton_coin_spend],
+            is_eligible_for_ff,
+            signing_puzzle=singleton_signing_puzzle,
+            signing_coin=singleton,
+        )
+        unspent_lineage_info = await sim_client.service.coin_store.get_unspent_lineage_info_for_puzzle_hash(
+            singleton_puzzle_hash
+        )
+        singleton_child, [remaining_coin] = await get_singleton_and_remaining_coins(sim)
+        assert singleton_child.amount == SINGLETON_CHILD_AMOUNT
+        assert unspent_lineage_info == UnspentLineageInfo(
+            coin_id=singleton_child.name(),
+            coin_amount=singleton_child.amount,
+            parent_id=singleton.name(),
+            parent_amount=singleton.amount,
+            parent_parent_id=eve_coin_spend.coin.name(),
+        )
+        # Now let's spend the first version again (despite being already spent by now)
+        remaining_spend_solution = SerializedProgram.from_program(
+            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount - diff_to_balance]])
+        )
+        remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
+        status, error = await make_and_send_spend_bundle(
+            sim,
+            sim_client,
+            [remaining_coin_spend, singleton_coin_spend],
+            is_eligible_for_ff,
+            signing_puzzle=singleton_signing_puzzle,
+            signing_coin=singleton,
+        )
+        if is_eligible_for_ff:
+            # Instead of rejecting this as double spend, we perform a fast forward,
+            # spending the singleton child as a result, and creating the latest
+            # version which is the grandchild in this scenario
+            assert status == MempoolInclusionStatus.SUCCESS
+            assert error is None
+            unspent_lineage_info = await sim_client.service.coin_store.get_unspent_lineage_info_for_puzzle_hash(
+                singleton_puzzle_hash
+            )
+            singleton_grandchild, [remaining_coin] = await get_singleton_and_remaining_coins(sim)
+            assert unspent_lineage_info == UnspentLineageInfo(
+                coin_id=singleton_grandchild.name(),
+                coin_amount=singleton_grandchild.amount,
+                parent_id=singleton_child.name(),
+                parent_amount=singleton_child.amount,
+                parent_parent_id=singleton.name(),
+            )
+        else:
+            # As this singleton is not eligible for fast forward, attempting to
+            # spend one of its earlier versions is considered a double spend
+            assert status == MempoolInclusionStatus.FAILED
+            assert error == Err.DOUBLE_SPEND
+@pytest.mark.anyio
+async def test_singleton_fast_forward_same_block() -> None:
+    """
+    This tests covers sending multiple transactions that spend an already spent
+    singleton version, all in the same block, to make sure they get properly
+    fast forwarded and chained down to a latest unspent version
+    """
+    START_AMOUNT = uint64(1337)
+    # We're decrementing the next iteration's amount for testing purposes
+    SINGLETON_AMOUNT = uint64(1335)
+    # We're incrementing the next iteration's amount for testing purposes
+    SINGLETON_CHILD_AMOUNT = uint64(1339)
+    async with sim_and_client() as (sim, sim_client):
+        singleton, eve_coin_spend, inner_puzzle, remaining_coin = await prepare_and_test_singleton(
+            sim, sim_client, True, START_AMOUNT, SINGLETON_AMOUNT
+        )
+        # Let's spend this first version, to create a bigger singleton child
+        singleton_puzzle_hash = eve_coin_spend.coin.puzzle_hash
+        inner_puzzle_hash = inner_puzzle.get_tree_hash()
+        inner_conditions = [
+            [ConditionOpcode.AGG_SIG_UNSAFE, G1Element(), IDENTITY_PUZZLE_HASH],
+            [ConditionOpcode.CREATE_COIN, inner_puzzle_hash, SINGLETON_CHILD_AMOUNT],
+        ]
+        singleton_coin_spend, _ = make_singleton_coin_spend(eve_coin_spend, singleton, inner_puzzle, inner_conditions)
+        # Spend also a remaining coin for balance, as we're increasing the singleton amount
+        diff_to_balance = SINGLETON_CHILD_AMOUNT - SINGLETON_AMOUNT
+        remaining_spend_solution = SerializedProgram.from_program(
+            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount - diff_to_balance]])
+        )
+        remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
+        await make_and_send_spend_bundle(sim, sim_client, [remaining_coin_spend, singleton_coin_spend])
+        unspent_lineage_info = await sim_client.service.coin_store.get_unspent_lineage_info_for_puzzle_hash(
+            singleton_puzzle_hash
+        )
+        singleton_child, [remaining_coin] = await get_singleton_and_remaining_coins(sim)
+        assert singleton_child.amount == SINGLETON_CHILD_AMOUNT
+        assert unspent_lineage_info == UnspentLineageInfo(
+            coin_id=singleton_child.name(),
+            coin_amount=singleton_child.amount,
+            parent_id=singleton.name(),
+            parent_amount=singleton.amount,
+            parent_parent_id=eve_coin_spend.coin.name(),
+        )
+        # Now let's send 3 arbitrary spends of the already spent singleton in
+        # one block. They should all properly fast forward
+        random_amounts = [21, 17, 11]
+        signature = G2Element()
+        for i in range(3):
+            # This cost adjustment allows us to maintain the order of spends due to fee per
+            # cost and amounts dynamics
+            cost_factor = (i + 1) * 5
+            inner_conditions = [
+                [ConditionOpcode.AGG_SIG_UNSAFE, G1Element(), IDENTITY_PUZZLE_HASH] for _ in range(cost_factor)
+            ]
+            inner_conditions.append([ConditionOpcode.CREATE_COIN, inner_puzzle_hash, random_amounts[i]])
+            singleton_coin_spend, _ = make_singleton_coin_spend(
+                eve_coin_spend, singleton, inner_puzzle, inner_conditions
+            )
+            status, error = await sim_client.push_tx(SpendBundle([singleton_coin_spend], signature))
+            assert error is None
+            assert status == MempoolInclusionStatus.SUCCESS
+        # Farm a block to process all these spend bundles
+        await sim.farm_block()
+        unspent_lineage_info = await sim_client.service.coin_store.get_unspent_lineage_info_for_puzzle_hash(
+            singleton_puzzle_hash
+        )
+        latest_singleton, [remaining_coin] = await get_singleton_and_remaining_coins(sim)
+        assert unspent_lineage_info is not None
+        # The unspent coin ID should reflect the latest version
+        assert unspent_lineage_info.coin_id == latest_singleton.name()
+        # The latest version should have the last random amount
+        assert latest_singleton.amount == random_amounts[-1]
+        # The unspent coin amount should reflect the latest version
+        assert unspent_lineage_info.coin_amount == latest_singleton.amount
+        # The unspent parent ID should reflect the latest version's parent
+        assert unspent_lineage_info.parent_id == latest_singleton.parent_coin_info
+        # The one before it should have the second last random amount
+        assert unspent_lineage_info.parent_amount == random_amounts[-2]

tests/core/test_cost_calculation.py CHANGED Viewed

         @@@ -146,7 -146,7 +146,7 @@@ async def test_mempool_mode(softfork_he
         binutils.assemble(
             f"(q ((0x3d2331635a58c0d49912bc1427d7db51afe3f20a7b4bcaffa17ee250dcbcbfaa {disassembly} 300"
             f"  (() (q . (({unknown_opcode} '00000000000000000000000000000000' 0x0cbba106e000))) ()))))"
-        ).as_bin()  # type: ignore[no-untyped-call]
+        ).as_bin()
     )
     generator = BlockGenerator(program, [], [])
     npc_result: NPCResult = get_name_puzzle_conditions(
         @@@ -169,7 -169,7 +169,7 @@@
     coin = Coin(
         bytes32.fromhex("3d2331635a58c0d49912bc1427d7db51afe3f20a7b4bcaffa17ee250dcbcbfaa"),
         bytes32.fromhex("14947eb0e69ee8fc8279190fc2d38cb4bbb61ba28f1a270cfd643a0e8d759576"),
-        300,
+        uint64(300),
     )
     spend_info = get_puzzle_and_solution_for_coin(generator, coin, softfork_height, bt.constants)
     assert spend_info.puzzle.to_program() == puzzle
         @@@ -183,9 -183,9 +183,7 @@@ async def test_clvm_mempool_mode(softfo
     # if-condition, that depends on executing an unknown operator
     # ("0xfe"). In mempool mode, this should fail, but in non-mempool
     # mode, the unknown operator should be treated as if it returns ().
-    program = SerializedProgram.from_bytes(
-        binutils.assemble(f"(i (0xfe (q . 0)) (q . ()) {disassembly})").as_bin()  # type: ignore[no-untyped-call]
-    )
+    program = SerializedProgram.from_bytes(binutils.assemble(f"(i (0xfe (q . 0)) (q . ()) {disassembly})").as_bin())
     generator = BlockGenerator(program, [], [])
     npc_result: NPCResult = get_name_puzzle_conditions(
         generator,
         @@@ -236,9 -236,9 +234,7 @@@ async def test_clvm_max_cost(softfork_h
     # mode, the unknown operator should be treated as if it returns ().
     # the CLVM program has a cost of 391969
     program = SerializedProgram.from_bytes(
-        binutils.assemble(
-            f"(i (softfork (q . 10000000)) (q . ()) {disassembly})"
-        ).as_bin()  # type: ignore[no-untyped-call]
+        binutils.assemble(f"(i (softfork (q . 10000000)) (q . ()) {disassembly})").as_bin()
     )
     # ensure we fail if the program exceeds the cost
         @@@ -273,7 -272,7 +269,7 @@@ async def test_standard_tx(benchmark_ru
     conditions = binutils.assemble(
         "((51 0x699eca24f2b6f4b25b16f7a418d0dc4fc5fce3b9145aecdda184158927738e3e 10)"
         " (51 0x847bb2385534070c39a39cc5dfdc7b35e2db472dc0ab10ab4dec157a2178adbf 0x00cbba106df6))"
-    )  # type: ignore[no-untyped-call]
+    )
     solution_program = SerializedProgram.from_bytes(
         bytes(p2_delegated_puzzle_or_hidden_puzzle.solution_for_conditions(conditions))
     )

tests/core/test_merkle_set.py CHANGED Viewed

         @@@ -4,17 -4,17 +4,23 @@@ import itertool
 import random
 from hashlib import sha256
 from itertools import permutations
-from typing import List
+from random import Random
+from typing import List, Optional, Tuple
 import pytest
-from chia_rs import compute_merkle_set_root
+from chia_rs import Coin, compute_merkle_set_root
+from chia.simulator.block_tools import BlockTools
 from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.hash import std_hash
+from chia.util.ints import uint64
 from chia.util.merkle_set import MerkleSet, confirm_included_already_hashed
+from chia.util.misc import to_batches
+from chia.wallet.util.wallet_sync_utils import validate_additions, validate_removals
 @pytest.mark.anyio
-async def test_basics(bt):
+async def test_basics(bt: BlockTools) -> None:
     num_blocks = 20
     blocks = bt.get_consecutive_blocks(num_blocks)
         @@@ -50,7 -50,7 +56,7 @@@ def hashdown(buf: bytes) -> bytes32
 @pytest.mark.anyio
-async def test_merkle_set_invalid_hash_size():
+async def test_merkle_set_invalid_hash_size() -> None:
     merkle_set = MerkleSet()
     # this is too large
         @@@ -76,7 -76,7 +82,7 @@@
 @pytest.mark.anyio
-async def test_merkle_set_1():
+async def test_merkle_set_1() -> None:
     a = bytes32([0x80] + [0] * 31)
     merkle_set = MerkleSet()
     merkle_set.add_already_hashed(a)
         @@@ -85,7 -85,7 +91,7 @@@
 @pytest.mark.anyio
-async def test_merkle_set_duplicate():
+async def test_merkle_set_duplicate() -> None:
     a = bytes32([0x80] + [0] * 31)
     merkle_set = MerkleSet()
     merkle_set.add_already_hashed(a)
         @@@ -95,14 -95,14 +101,14 @@@
 @pytest.mark.anyio
-async def test_merkle_set_0():
+async def test_merkle_set_0() -> None:
     merkle_set = MerkleSet()
     assert merkle_set.get_root() == bytes32(compute_merkle_set_root([]))
     assert merkle_set.get_root() == bytes32([0] * 32)
 @pytest.mark.anyio
-async def test_merkle_set_2():
+async def test_merkle_set_2() -> None:
     a = bytes32([0x80] + [0] * 31)
     b = bytes32([0x70] + [0] * 31)
     merkle_set = MerkleSet()
         @@@ -113,7 -113,7 +119,7 @@@
 @pytest.mark.anyio
-async def test_merkle_set_2_reverse():
+async def test_merkle_set_2_reverse() -> None:
     a = bytes32([0x80] + [0] * 31)
     b = bytes32([0x70] + [0] * 31)
     merkle_set = MerkleSet()
         @@@ -124,7 -124,7 +130,7 @@@
 @pytest.mark.anyio
-async def test_merkle_set_3():
+async def test_merkle_set_3() -> None:
     a = bytes32([0x80] + [0] * 31)
     b = bytes32([0x70] + [0] * 31)
     c = bytes32([0x71] + [0] * 31)
         @@@ -145,7 -145,7 +151,7 @@@
 @pytest.mark.anyio
-async def test_merkle_set_4():
+async def test_merkle_set_4() -> None:
     a = bytes32([0x80] + [0] * 31)
     b = bytes32([0x70] + [0] * 31)
     c = bytes32([0x71] + [0] * 31)
         @@@ -167,7 -167,7 +173,7 @@@
 @pytest.mark.anyio
-async def test_merkle_set_5():
+async def test_merkle_set_5() -> None:
     BLANK = bytes32([0] * 32)
     a = bytes32([0x58] + [0] * 31)
         @@@ -216,7 -216,7 +222,7 @@@
 @pytest.mark.anyio
-async def test_merkle_left_edge():
+async def test_merkle_left_edge() -> None:
     BLANK = bytes32([0] * 32)
     a = bytes32([0x80] + [0] * 31)
     b = bytes32([0] * 31 + [1])
         @@@ -257,7 -257,7 +263,7 @@@
 @pytest.mark.anyio
-async def test_merkle_right_edge():
+async def test_merkle_right_edge() -> None:
     BLANK = bytes32([0] * 32)
     a = bytes32([0x40] + [0] * 31)
     b = bytes32([0xFF] * 31 + [0xFF])
         @@@ -306,7 -306,7 +312,7 @@@ def rand_hash(rng: random.Random) -> by
 @pytest.mark.anyio
 @pytest.mark.skip("This test is expensive and has already convinced us there are no discrepancies")
-async def test_merkle_set_random_regression():
+async def test_merkle_set_random_regression() -> None:
     rng = random.Random()
     rng.seed(123456)
     for i in range(100):
         @@@ -323,3 -323,3 +329,44 @@@
             python_root = merkle_set.get_root()
             rust_root = bytes32(compute_merkle_set_root(values))
             assert rust_root == python_root
+def make_test_coins(n: int, rng: Random) -> List[Coin]:
+    return [Coin(bytes32.random(rng), bytes32.random(rng), uint64(rng.randint(0, 10000000))) for i in range(n)]
+@pytest.mark.parametrize("num_coins", [0, 1, 2, 100, 1337])
+def test_validate_removals_full_list(num_coins: int, seeded_random: Random) -> None:
+    # when we have all the removals, we don't need to include a proof, because
+    # the root can be computed by all the removals
+    coins = make_test_coins(num_coins, seeded_random)
+    removals_merkle_set = MerkleSet()
+    coin_map: List[Tuple[bytes32, Optional[Coin]]] = []
+    for coin in coins:
+        removals_merkle_set.add_already_hashed(coin.name())
+        coin_map.append((coin.name(), coin))
+    removals_root = removals_merkle_set.get_root()
+    assert validate_removals(coin_map, None, removals_root) is True
+@pytest.mark.parametrize("num_coins", [0, 1, 2, 100, 1337])
+@pytest.mark.parametrize("batch_size", [1, 2, 10])
+def test_validate_additions_full_list(num_coins: int, batch_size: int, seeded_random: Random) -> None:
+    # when we have all the removals, we don't need to include a proof, because
+    # the root can be computed by all the removals
+    coins = make_test_coins(num_coins, seeded_random)
+    additions_merkle_set = MerkleSet()
+    additions: List[Tuple[bytes32, List[Coin]]] = []
+    for coin_batch in to_batches(coins, batch_size):
+        puzzle_hash = bytes32.random(seeded_random)
+        additions.append((puzzle_hash, coin_batch.entries))
+        additions_merkle_set.add_already_hashed(puzzle_hash)
+        additions_merkle_set.add_already_hashed(
+            std_hash(b"".join(sorted([coin.name() for coin in coin_batch.entries], reverse=True)))
+        )
+    additions_root = additions_merkle_set.get_root()
+    assert validate_additions(additions, None, additions_root) is True

tests/core/test_program.py CHANGED Viewed

         @@@ -1,49 -1,0 +1,49 @@@
+from __future__ import annotations
+from typing import List
+from clvm.SExp import CastableType
+from clvm_tools import binutils
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint32, uint64
+def program_roundtrip(o: CastableType) -> None:
+    prg1 = Program.to(o)
+    prg2 = SerializedProgram.to(o)
+    prg3 = SerializedProgram.from_program(prg1)
+    prg4 = SerializedProgram.from_bytes(prg1.as_bin())
+    prg5 = prg2.to_program()
+    assert bytes(prg1) == bytes(prg2)
+    assert bytes(prg1) == bytes(prg3)
+    assert bytes(prg1) == bytes(prg4)
+    assert bytes(prg1) == bytes(prg5)
+def test_serialized_program_to() -> None:
+    prg = "(q ((0x0101010101010101010101010101010101010101010101010101010101010101 80 123 (() (q . ())))))"  # noqa
+    tests: List[CastableType] = [
+        0,
+        1,
+        (1, 2),
+        [0, 1, 2],
+        Program.to([1, 2, 3]),
+        SerializedProgram.to([1, 2, 3]),
+        b"123",
-        binutils.assemble(prg),  # type: ignore[no-untyped-call]
+        binutils.assemble(prg),
+        [b"1", b"2", b"3"],
+        (b"1", (b"2", b"3")),
+        None,
+        -24,
+        bytes32.fromhex("0" * 64),
+        bytes.fromhex("0" * 6),
+        uint32(123),
+        uint64(123123),
+    ]
+    for t in tests:
+        program_roundtrip(t)

tests/core/util/test_streamable.py ADDED Viewed

         @@@ -652,7 -652,7 +652,7 @@@ def test_ambiguous_deserialization_prog
     class TestClassProgram(Streamable):
         a: Program
-    program = Program.to(binutils.assemble("()"))  # type: ignore[no-untyped-call]  # TODO, add typing in clvm_tools
+    program = Program.to(binutils.assemble("()"))
     TestClassProgram.from_bytes(bytes(program))

tests/ether.py RENAMED Viewed

         @@@ -1,0 -1,0 +1,19 @@@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Callable, Optional
+if TYPE_CHECKING:
+    from tests.util.misc import TestId
+# NOTE: Do not just put any useful thing here.  This is specifically for making
+#       fixture values globally available during tests.  In _most_ cases fixtures
+#       should be directly requested using normal mechanisms.  Very little should
+#       be put here.
+# NOTE: When using this module do not import the attributes directly.  Rather, import
+#       something like `from tests import ether`.  Importing attributes directly will
+#       result in you likely getting the default `None` values since they are not
+#       populated until tests are running.
+record_property: Optional[Callable[[str, object], None]] = None
+test_id: Optional[TestId] = None

tests/farmer_harvester/test_third_party_harvesters.py CHANGED Viewed

         @@@ -1,470 -1,0 +1,470 @@@
+from __future__ import annotations
+import asyncio
+import base64
+import dataclasses
+import json
+import logging
+from os.path import dirname
+from typing import Any, List, Optional, Tuple, Union, cast
+import pytest
+from chia_rs import G1Element
+from pytest_mock import MockerFixture
+from chia.consensus.blockchain import AddBlockResult
+from chia.consensus.multiprocess_validation import PreValidationResult
+from chia.farmer.farmer import Farmer, calculate_harvester_fee_quality
+from chia.farmer.farmer_api import FarmerAPI
+from chia.full_node.full_node import FullNode
+from chia.full_node.full_node_api import FullNodeAPI
+from chia.harvester.harvester import Harvester
+from chia.harvester.harvester_api import HarvesterAPI
+from chia.protocols import farmer_protocol, full_node_protocol, harvester_protocol, timelord_protocol
+from chia.protocols.farmer_protocol import RequestSignedValues
+from chia.protocols.harvester_protocol import ProofOfSpaceFeeInfo, RespondSignatures, SigningDataKind
+from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.server.outbound_message import Message, NodeType, make_msg
+from chia.server.server import ChiaServer
+from chia.server.ws_connection import WSChiaConnection
+from chia.simulator.block_tools import BlockTools
+from chia.types.aliases import FarmerService, FullNodeService, HarvesterService, SimulatorFullNodeService
+from chia.types.blockchain_format.classgroup import ClassgroupElement
+from chia.types.blockchain_format.foliage import FoliageBlockData, FoliageTransactionBlock
+from chia.types.blockchain_format.proof_of_space import ProofOfSpace
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.blockchain_format.slots import ChallengeChainSubSlot, RewardChainSubSlot
+from chia.types.full_block import FullBlock
+from chia.types.peer_info import UnresolvedPeerInfo
+from chia.util.bech32m import decode_puzzle_hash
+from chia.util.hash import std_hash
+from chia.util.ints import uint8, uint32, uint64
+from tests.util.time_out_assert import time_out_assert
+SPType = Union[timelord_protocol.NewEndOfSubSlotVDF, timelord_protocol.NewSignagePointVDF]
+SPList = List[SPType]
+@pytest.mark.anyio
+async def test_harvester_receive_source_signing_data(
+    farmer_harvester_2_simulators_zero_bits_plot_filter: Tuple[
+        FarmerService,
+        HarvesterService,
+        Union[FullNodeService, SimulatorFullNodeService],
+        Union[FullNodeService, SimulatorFullNodeService],
+        BlockTools,
+    ],
+    mocker: MockerFixture,
+) -> None:
+    """
+    Tests that the source data for the signatures requests sent to the
+    harvester are indeed available and also tests that overrides of
+    the farmer reward address, as specified by the harvester, are respected.
+    See: CHIP-22: https://github.com/Chia-Network/chips/pull/88
+    """
+    (
+        farmer_service,
+        harvester_service,
+        full_node_service_1,
+        full_node_service_2,
+        _,
+    ) = farmer_harvester_2_simulators_zero_bits_plot_filter
+    farmer: Farmer = farmer_service._node
+    harvester: Harvester = harvester_service._node
+    full_node_1: FullNode = full_node_service_1._node
+    full_node_2: FullNode = full_node_service_2._node
+    # Connect peers to each other
+    farmer_service.add_peer(
+        UnresolvedPeerInfo(str(full_node_service_2.self_hostname), full_node_service_2._server.get_port())
+    )
+    full_node_service_2.add_peer(
+        UnresolvedPeerInfo(str(full_node_service_1.self_hostname), full_node_service_1._server.get_port())
+    )
+    await wait_until_node_type_connected(farmer.server, NodeType.FULL_NODE)
+    await wait_until_node_type_connected(farmer.server, NodeType.HARVESTER)  # Should already be connected
+    await wait_until_node_type_connected(full_node_1.server, NodeType.FULL_NODE)
+    # Prepare test data
+    blocks: List[FullBlock]
+    signage_points: SPList
+    (blocks, signage_points) = load_test_data()
+    assert len(blocks) == 1
+    # Inject full node with a pre-existing block to skip initial genesis sub-slot
+    # so that we have blocks generated that have our farmer reward address, instead
+    # of the GENESIS_PRE_FARM_FARMER_PUZZLE_HASH.
+    await add_test_blocks_into_full_node(blocks, full_node_2)
+    validated_foliage_data = False
+    validated_foliage_transaction = False
+    validated_cc_vdf = False
+    validated_rc_vdf = False
+    validated_sub_slot_cc = False
+    validated_sub_slot_rc = False
+    # validated_partial = False     # Not covered currently. See comment in validate_harvester_request_signatures
+    finished_validating_data = False
+    farmer_reward_address = decode_puzzle_hash("txch1psqeaw0h244v5sy2r4se8pheyl62n8778zl6t5e7dep0xch9xfkqhx2mej")
+    async def intercept_harvester_request_signatures(*args: Any) -> Message:
+        request: harvester_protocol.RequestSignatures = harvester_protocol.RequestSignatures.from_bytes(args[0])
+        nonlocal harvester
+        nonlocal farmer_reward_address
+        validate_harvester_request_signatures(request)
+        result_msg: Optional[Message] = await HarvesterAPI.request_signatures(
+            cast(HarvesterAPI, harvester.server.api), request
+        )
+        assert result_msg is not None
+        # Inject overridden farmer reward address
+        response: RespondSignatures = dataclasses.replace(
+            RespondSignatures.from_bytes(result_msg.data), farmer_reward_address_override=farmer_reward_address
+        )
+        return make_msg(ProtocolMessageTypes.respond_signatures, response)
+    def validate_harvester_request_signatures(request: harvester_protocol.RequestSignatures) -> None:
+        nonlocal full_node_2
+        nonlocal farmer_reward_address
+        nonlocal validated_foliage_data
+        nonlocal validated_foliage_transaction
+        nonlocal validated_cc_vdf
+        nonlocal validated_rc_vdf
+        nonlocal validated_sub_slot_cc
+        nonlocal validated_sub_slot_rc
+        nonlocal finished_validating_data
+        assert request.message_data is not None
+        assert len(request.messages) > 0
+        assert len(request.messages) == len(request.message_data)
+        for hash, src in zip(request.messages, request.message_data):
+            assert hash
+            assert src
+            data: Optional[
+                Union[
+                    FoliageBlockData,
+                    FoliageTransactionBlock,
+                    ClassgroupElement,
+                    ChallengeChainSubSlot,
+                    RewardChainSubSlot,
+                ]
+            ] = None
+            if src.kind == uint8(SigningDataKind.FOLIAGE_BLOCK_DATA):
+                data = FoliageBlockData.from_bytes(src.data)
+                assert (
+                    data.farmer_reward_puzzle_hash == farmer_reward_address
+                    or data.farmer_reward_puzzle_hash
+                    == bytes32(full_node_2.constants.GENESIS_PRE_FARM_FARMER_PUZZLE_HASH)
+                )
+                if data.farmer_reward_puzzle_hash == farmer_reward_address:
+                    validated_foliage_data = True
+            elif src.kind == uint8(SigningDataKind.FOLIAGE_TRANSACTION_BLOCK):
+                data = FoliageTransactionBlock.from_bytes(src.data)
+                validated_foliage_transaction = True
+            elif src.kind == uint8(SigningDataKind.CHALLENGE_CHAIN_VDF):
+                data = ClassgroupElement.from_bytes(src.data)
+                validated_cc_vdf = True
+            elif src.kind == uint8(SigningDataKind.REWARD_CHAIN_VDF):
+                data = ClassgroupElement.from_bytes(src.data)
+                validated_rc_vdf = True
+            elif src.kind == uint8(SigningDataKind.CHALLENGE_CHAIN_SUB_SLOT):
+                data = ChallengeChainSubSlot.from_bytes(src.data)
+                validated_sub_slot_cc = True
+            elif src.kind == uint8(SigningDataKind.REWARD_CHAIN_SUB_SLOT):
+                data = RewardChainSubSlot.from_bytes(src.data)
+                validated_sub_slot_rc = True
+            # #NOTE: This data type is difficult to trigger, so it is
+            #        not tested for the time being.
+            # data = PostPartialPayload.from_bytes(src.data)
+            # validated_partial = True
+            # elif src.kind == uint8(SigningDataKind.PARTIAL):
+            #     pass
+            finished_validating_data = (
+                validated_foliage_data
+                and validated_foliage_transaction
+                and validated_cc_vdf
+                and validated_rc_vdf
+                and validated_sub_slot_cc
+                and validated_sub_slot_rc
+            )
+            assert data is not None
+            data_hash = data.get_hash()
+            assert data_hash == hash
+    async def intercept_farmer_new_proof_of_space(*args: Any) -> None:
+        nonlocal farmer
+        nonlocal farmer_reward_address
+        request: harvester_protocol.NewProofOfSpace = dataclasses.replace(
+            harvester_protocol.NewProofOfSpace.from_bytes(args[0]), farmer_reward_address_override=farmer_reward_address
+        )
+        peer: WSChiaConnection = args[1]
+        await FarmerAPI.new_proof_of_space(farmer.server.api, request, peer)
+    async def intercept_farmer_request_signed_values(*args: Any) -> Optional[Message]:
+        nonlocal farmer
+        nonlocal farmer_reward_address
+        nonlocal full_node_2
+        request: RequestSignedValues = RequestSignedValues.from_bytes(args[0])
+        # Ensure the FullNode included the source data for the signatures
+        assert request.foliage_block_data
+        assert request.foliage_block_data.get_hash() == request.foliage_block_data_hash
+        assert request.foliage_transaction_block_data
+        assert request.foliage_transaction_block_data.get_hash() == request.foliage_transaction_block_hash
+        assert (
+            request.foliage_block_data.farmer_reward_puzzle_hash == farmer_reward_address
+            or request.foliage_block_data.farmer_reward_puzzle_hash
+            == bytes32(full_node_2.constants.GENESIS_PRE_FARM_FARMER_PUZZLE_HASH)
+        )
+        return await FarmerAPI.request_signed_values(farmer.server.api, request)
+    mocker.patch.object(farmer.server.api, "request_signed_values", side_effect=intercept_farmer_request_signed_values)
+    mocker.patch.object(farmer.server.api, "new_proof_of_space", side_effect=intercept_farmer_new_proof_of_space)
+    mocker.patch.object(harvester.server.api, "request_signatures", side_effect=intercept_harvester_request_signatures)
+    # Start injecting signage points
+    await inject_signage_points(signage_points, full_node_1, full_node_2)
+    # Wait until test finishes
+    def did_finished_validating_data() -> bool:
+        return finished_validating_data
+    await time_out_assert(60 * 60, did_finished_validating_data, True)
+@pytest.mark.anyio
+async def test_harvester_fee_convention(
+    farmer_harvester_2_simulators_zero_bits_plot_filter: Tuple[
+        FarmerService,
+        HarvesterService,
+        Union[FullNodeService, SimulatorFullNodeService],
+        Union[FullNodeService, SimulatorFullNodeService],
+        BlockTools,
+    ],
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """
+    Tests fee convention specified in CHIP-22: https://github.com/Chia-Network/chips/pull/88
+    """
+    (
+        farmer_service,
+        _,
+        _,
+        _,
+        _,
+    ) = farmer_harvester_2_simulators_zero_bits_plot_filter
+    caplog.set_level(logging.DEBUG)
+    farmer: Farmer = farmer_service._node
+    (sp, pos) = prepare_sp_and_pos_for_fee_test(1)
+    farmer.notify_farmer_reward_taken_by_harvester_as_fee(sp, pos)
+    assert await scan_log_for_message(caplog, "Fee threshold passed for challenge")
+@pytest.mark.anyio
+async def test_harvester_fee_invalid_convention(
+    farmer_harvester_2_simulators_zero_bits_plot_filter: Tuple[
+        FarmerService,
+        HarvesterService,
+        Union[FullNodeService, SimulatorFullNodeService],
+        Union[FullNodeService, SimulatorFullNodeService],
+        BlockTools,
+    ],
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """
+    Tests that logs are properly emitted when an invalid free threshold is specified
+    given the fee convention from CHIP-22: https://github.com/Chia-Network/chips/pull/88
+    """
+    (
+        farmer_service,
+        _,
+        _,
+        _,
+        _,
+    ) = farmer_harvester_2_simulators_zero_bits_plot_filter
+    farmer: Farmer = farmer_service._node
+    caplog.set_level(logging.DEBUG)
+    (sp, pos) = prepare_sp_and_pos_for_fee_test(-1)
+    farmer.notify_farmer_reward_taken_by_harvester_as_fee(sp, pos)
+    farmer.log.propagate
+    assert await scan_log_for_message(caplog, "Invalid fee threshold for challenge")
+def prepare_sp_and_pos_for_fee_test(
+    fee_threshold_offset: int,
+) -> Tuple[farmer_protocol.NewSignagePoint, harvester_protocol.NewProofOfSpace]:
+    proof = std_hash(b"1")
+    challenge = std_hash(b"1")
+    fee_quality = calculate_harvester_fee_quality(proof, challenge)
+    pubkey = G1Element.from_bytes(
+        bytes.fromhex(
+            "80a836a74b077cabaca7a76d1c3c9f269f7f3a8f2fa196a65ee8953eb81274eb8b7328d474982617af5a0fe71b47e9b8"
+        )
+    )
+    # Send some fake data to the framer
+    sp = farmer_protocol.NewSignagePoint(
+        challenge_hash=challenge,
+        challenge_chain_sp=challenge,
+        reward_chain_sp=challenge,
+        difficulty=uint64(0),
+        sub_slot_iters=uint64(0),
+        signage_point_index=uint8(0),
+        peak_height=uint32(1),
+    )
+    pos = harvester_protocol.NewProofOfSpace(
+        challenge_hash=challenge,
+        sp_hash=challenge,
+        plot_identifier="foo.plot",
+        proof=ProofOfSpace(
+            challenge=challenge,
+            pool_public_key=None,
+            pool_contract_puzzle_hash=None,
+            plot_public_key=pubkey,
-            size=len(proof),
+            size=uint8(len(proof)),
+            proof=proof,
+        ),
+        signage_point_index=uint8(0),
+        include_source_signature_data=False,
+        farmer_reward_address_override=decode_puzzle_hash(
+            "txch1psqeaw0h244v5sy2r4se8pheyl62n8778zl6t5e7dep0xch9xfkqhx2mej"
+        ),
+        fee_info=ProofOfSpaceFeeInfo(
+            # Apply threshold offset to make the fee either pass or fail
+            applied_fee_threshold=uint32(fee_quality + fee_threshold_offset)
+        ),
+    )
+    return (sp, pos)
+async def scan_log_for_message(caplog: pytest.LogCaptureFixture, find_message: str) -> bool:  # pragma: no cover
+    log_text_len = 0
+    def log_has_new_text() -> bool:
+        nonlocal caplog
+        nonlocal log_text_len
+        text_len = len(caplog.text)
+        if text_len > log_text_len:
+            log_text_len = text_len
+            return True
+        return False
+    await time_out_assert(60, log_has_new_text, True)
+    log_text = caplog.text
+    find_index = 0
+    fail_count = 0
+    max_fails = 10
+    for _ in range(max_fails):
+        index = log_text.find(find_message, find_index)
+        if index >= 0:
+            return True
+        fail_count += 1
+        assert fail_count < max_fails
+        await time_out_assert(10, log_has_new_text, True)
+        log_text = caplog.text
+    return False
+async def wait_until_node_type_connected(server: ChiaServer, node_type: NodeType) -> WSChiaConnection:
+    while True:
+        for peer in server.all_connections.values():
+            if peer.connection_type == node_type.value:
+                return peer
+        await asyncio.sleep(1)
+def decode_sp(
+    is_sub_slot: bool, sp64: str
+) -> Union[timelord_protocol.NewEndOfSubSlotVDF, timelord_protocol.NewSignagePointVDF]:
+    sp_bytes = base64.b64decode(sp64)
+    if is_sub_slot:
+        return timelord_protocol.NewEndOfSubSlotVDF.from_bytes(sp_bytes)
+    return timelord_protocol.NewSignagePointVDF.from_bytes(sp_bytes)
+async def add_test_blocks_into_full_node(blocks: List[FullBlock], full_node: FullNode) -> None:
+    # Inject full node with a pre-existing block to skip initial genesis sub-slot
+    # so that we have blocks generated that have our farmer reward address, instead
+    # of the GENESIS_PRE_FARM_FARMER_PUZZLE_HASH.
+    pre_validation_results: List[PreValidationResult] = await full_node.blockchain.pre_validate_blocks_multiprocessing(
+        blocks, {}, validate_signatures=True
+    )
+    assert pre_validation_results is not None and len(pre_validation_results) == len(blocks)
+    for i in range(len(blocks)):
+        r, _, _ = await full_node.blockchain.add_block(blocks[i], pre_validation_results[i])
+        assert r == AddBlockResult.NEW_PEAK
+async def inject_signage_points(signage_points: SPList, full_node_1: FullNode, full_node_2: FullNode) -> None:
+    full_node_2_peer_1 = [
+        n for n in list(full_node_2.server.all_connections.values()) if n.local_type == NodeType.FULL_NODE
+    ][0]
+    api2 = cast(FullNodeAPI, full_node_2.server.api)
+    for i, sp in enumerate(signage_points):
+        req: Union[full_node_protocol.RespondEndOfSubSlot, full_node_protocol.RespondSignagePoint]
+        if isinstance(sp, timelord_protocol.NewEndOfSubSlotVDF):
+            full_node_1.log.info(f"Injecting SP for end of sub-slot @ {i}")
+            req = full_node_protocol.RespondEndOfSubSlot(sp.end_of_sub_slot_bundle)
+            await api2.respond_end_of_sub_slot(req, full_node_2_peer_1)
+        else:
+            full_node_1.log.info(f"Injecting SP @ {i}: index: {sp.index_from_challenge}")
+            req = full_node_protocol.RespondSignagePoint(
+                sp.index_from_challenge,
+                sp.challenge_chain_sp_vdf,
+                sp.challenge_chain_sp_proof,
+                sp.reward_chain_sp_vdf,
+                sp.reward_chain_sp_proof,
+            )
+            await api2.respond_signage_point(req, full_node_2_peer_1)
+# Pre-generated test signage points encoded as base64.
+# Each element contains either a NewSignagePointVDF or a NewEndOfSubSlotVDF.
+# If the first element of the tuple is True, then it is as NewEndOfSubSlotVDF.
+# A FullBlock is also included which is infused already in the chain so
+# that the next NewEndOfSubSlotVDF is valid.
+# This block has to be added to the test FullNode before injecting the signage points.
+def load_test_data() -> Tuple[List[FullBlock], SPList]:
+    file_path: str = dirname(__file__) + "/test_third_party_harvesters_data.json"
+    with open(file_path) as f:
+        data = json.load(f)
+        blocks = [FullBlock.from_bytes(base64.b64decode(cast(str, data["block"])))]
+        signage_points = [decode_sp(cast(bool, sp[0]), cast(str, sp[1])) for sp in data["signage_points"]]
+        return (blocks, signage_points)

tests/generator/test_compression.py CHANGED Viewed

         @@@ -217,7 -217,7 +217,7 @@@ class TestDecompression
     def test_decompress_cse(self) -> None:
         """Decompress a single CSE / CoinSpendEntry"""
-        cse0 = binutils.assemble(  # type: ignore[no-untyped-call]
+        cse0 = binutils.assemble(
             "((0x0000000000000000000000000000000000000000000000000000000000000000 0x0186a0) (0xb081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3 (() (q (51 0x6b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9 0x0186a0)) ())))"
         )
         cost, out = DECOMPRESS_CSE.run_with_cost(
         @@@ -228,7 -228,7 +228,7 @@@
         print(out)
     def test_decompress_cse_with_prefix(self) -> None:
-        cse0 = binutils.assemble(  # type: ignore[no-untyped-call]
+        cse0 = binutils.assemble(
             "((0x0000000000000000000000000000000000000000000000000000000000000000 0x0186a0) (0xb081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3 (() (q (51 0x6b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9 0x0186a0)) ())))"
         )
         @@@ -245,10 -245,10 +245,10 @@@
     def test_block_program_zero(self) -> None:
         "Decompress a list of CSEs"
-        cse1 = binutils.assemble(  # type: ignore[no-untyped-call]
+        cse1 = binutils.assemble(
             "(((0x0000000000000000000000000000000000000000000000000000000000000000 0x0186a0) (0xb081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3 (() (q (51 0x6b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9 0x0186a0)) ()))))"
         )
-        cse2 = binutils.assemble(  # type: ignore[no-untyped-call]
+        cse2 = binutils.assemble(
             """
 (
   ((0x0000000000000000000000000000000000000000000000000000000000000000 0x0186a0)
         @@@ -286,10 -286,10 +286,10 @@@
         print(out)
     def test_block_program_zero_with_curry(self) -> None:
-        cse1 = binutils.assemble(  # type: ignore[no-untyped-call]
+        cse1 = binutils.assemble(
             "(((0x0000000000000000000000000000000000000000000000000000000000000000 0x0186a0) (0xb081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3 (() (q (51 0x6b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9 0x0186a0)) ()))))"
         )
-        cse2 = binutils.assemble(  # type: ignore[no-untyped-call]
+        cse2 = binutils.assemble(
             """
 (
   ((0x0000000000000000000000000000000000000000000000000000000000000000 0x0186a0)

tests/generator/test_rom.py DELETED Viewed

         @@@ -46,7 -46,7 +46,7 @@@ GENERATOR_CODE = ""
 COMPILED_GENERATOR_CODE = bytes(Program.to(compile_clvm_text(GENERATOR_CODE, [])))  # type: ignore[no-untyped-call]
 FIRST_GENERATOR = Program.to(
-    binutils.assemble(  # type: ignore[no-untyped-call]
+    binutils.assemble(
         """
         ((0x0000000000000000000000000000000000000000000000000000000000000000 1 50000
         ((51 0x0000000000000000000000000000000000000000000000000000000000000001 500))
         @@@ -54,7 -54,7 +54,7 @@@
     )
 ).as_bin()
-SECOND_GENERATOR = Program.to(binutils.assemble("(extra data for block)")).as_bin()  # type: ignore[no-untyped-call]
+SECOND_GENERATOR = Program.to(binutils.assemble("(extra data for block)")).as_bin()
 def to_sp(sexp: bytes) -> SerializedProgram:

tests/process_benchmarks.py ADDED Viewed

         @@@ -1,240 -1,240 +1,0 @@@
-from __future__ import annotations
-import json
-import random
-import re
-from collections import defaultdict
-from dataclasses import dataclass, field
-from pathlib import Path
-from statistics import StatisticsError, mean, stdev
-from typing import Any, Dict, List, Set, TextIO, Tuple, final
-import click
-import lxml.etree
-@final
-@dataclass(frozen=True, order=True)
-class Result:
-    file_path: Path
-    test_path: Tuple[str, ...]
-    label: str
-    line: int = field(compare=False)
-    durations: Tuple[float, ...] = field(compare=False)
-    limit: float = field(compare=False)
-    def marshal(self) -> Dict[str, Any]:
-        return {
-            "file_path": self.file_path.as_posix(),
-            "test_path": self.test_path,
-            "label": self.label,
-            "duration": {
-                "all": self.durations,
-                "min": min(self.durations),
-                "max": max(self.durations),
-                "mean": mean(self.durations),
-            },
-        }
-    def link(self, prefix: str, line_separator: str) -> str:
-        return f"{prefix}{self.file_path.as_posix()}{line_separator}{self.line}"
-def sub(matchobj: re.Match[str]) -> str:
-    result = ""
-    if matchobj.group("start") == "[":
-        result += "["
-    if matchobj.group("start") == matchobj.group("end") == "-":
-        result += "-"
-    if matchobj.group("end") == "]":
-        result += "]"
-    return result
-@click.command(context_settings={"help_option_names": ["-h", "--help"]})
-@click.option(
-    "--xml",
-    "xml_file",
-    required=True,
-    type=click.File(),
-    help="The benchmarks JUnit XML results file",
-)
-@click.option(
-    "--link-prefix",
-    default="",
-    help="Prefix for output links such as for web links instead of IDE links",
-    show_default=True,
-)
-@click.option(
-    "--link-line-separator",
-    default=":",
-    help="The separator between the path and the line number, such as : for local links and #L on GitHub",
-    show_default=True,
-)
-@click.option(
-    "--output",
-    default="-",
-    type=click.File(mode="w", encoding="utf-8", lazy=True, atomic=True),
-    help="Output file, - for stdout",
-    show_default=True,
-)
-# TODO: anything but this pattern for output types
-@click.option(
-    "--markdown/--no-markdown",
-    help="Use markdown as output format",
-    show_default=True,
-)
-@click.option(
-    "--percent-margin",
-    default=15,
-    type=int,
-    help="Highlight results with maximums within this percent of the limit",
-    show_default=True,
-)
-@click.option(
-    "--randomoji/--determimoji",
-    help="≡ƒì┐",
-    show_default=True,
-)
-def main(
-    xml_file: TextIO,
-    link_prefix: str,
-    link_line_separator: str,
-    output: TextIO,
-    markdown: bool,
-    percent_margin: int,
-    randomoji: bool,
-) -> None:
-    tree = lxml.etree.parse(xml_file)
-    root = tree.getroot()
-    benchmarks = root.find("testsuite[@name='benchmarks']")
-    # raw_durations: defaultdict[Tuple[str, ...], List[Result]] = defaultdict(list)
-    cases_by_test_path: defaultdict[Tuple[str, ...], List[lxml.etree.Element]] = defaultdict(list)
-    for case in benchmarks.findall("testcase"):
-        raw_name = case.attrib["name"]
-        name = re.sub(r"(?P<start>[-\[])benchmark_repeat\d{3}(?P<end>[-\])])", sub, raw_name)
-        # TODO: seems to duplicate the class and function name, though not the parametrizations
-        test_path = (
-            *case.attrib["classname"].split("."),
-            name,
-        )
-        cases_by_test_path[test_path].append(case)
-    results: List[Result] = []
-    for test_path, cases in cases_by_test_path.items():
-        labels: Set[str] = set()
-        for case in cases:
-            properties = case.find("properties")
-            labels.update(property.attrib["name"].partition(":")[2] for property in properties)
-        for label in labels:
-            query = "properties/property[@name='{property}:{label}']"
-            durations = [
-                float(property.attrib["value"])
-                for case in cases
-                for property in case.xpath(query.format(label=label, property="duration"))
-            ]
-            a_case = cases[0]
-            file_path: Path
-            [file_path] = [
-                Path(property.attrib["value"]) for property in a_case.xpath(query.format(label=label, property="path"))
-            ]
-            line: int
-            [line] = [
-                int(property.attrib["value"]) for property in a_case.xpath(query.format(label=label, property="line"))
-            ]
-            limit: float
-            [limit] = [
-                float(property.attrib["value"])
-                for property in a_case.xpath(query.format(label=label, property="limit"))
-            ]
-            results.append(
-                Result(
-                    file_path=file_path,
-                    test_path=test_path,
-                    line=line,
-                    label=label,
-                    durations=tuple(durations),
-                    limit=limit,
-                )
-            )
-    if not markdown:
-        for result in results:
-            link = result.link(prefix=link_prefix, line_separator=link_line_separator)
-            dumped = json.dumps(result.marshal())
-            output.write(f"{link} {dumped}\n")
-    else:
-        output.write("| Test | ≡ƒì┐ | Mean | Max | 3╧â | Limit | Percent |\n")
-        output.write("| --- | --- | --- | --- | --- | --- | --- |\n")
-        for result in sorted(results):
-            link_url = result.link(prefix=link_prefix, line_separator=link_line_separator)
-            mean_str = "-"
-            three_sigma_str = "-"
-            if len(result.durations) > 1:
-                durations_mean = mean(result.durations)
-                mean_str = f"{durations_mean:.3f} s"
-                try:
-                    three_sigma_str = f"{durations_mean + 3 * stdev(result.durations):.3f} s"
-                except StatisticsError:
-                    pass
-            durations_max = max(result.durations)
-            max_str = f"{durations_max:.3f} s"
-            limit_str = f"{result.limit:.3f} s"
-            percent = 100 * durations_max / result.limit
-            if percent >= 100:
-                # intentionally biasing towards ≡ƒìä
-                choices = "≡ƒìä≡ƒìä≡ƒìÄ≡ƒìà"  # ≡ƒî╢∩╕Å≡ƒìë≡ƒìÆ≡ƒìô
-            elif percent >= (100 - percent_margin):
-                choices = "≡ƒìï≡ƒìî"  # ≡ƒìì≡ƒî╜
-            else:
-                choices = "≡ƒ½¢≡ƒìê≡ƒìÅ≡ƒìÉ≡ƒÑ¥≡ƒÑÆ≡ƒÑ¼≡ƒÑª"
-            marker: str
-            if randomoji:
-                marker = random.choice(choices)
-            else:
-                marker = choices[0]
-            percent_str = f"{percent:.0f} %"
-            test_path_str = ".".join(result.test_path[1:])
-            test_link_text: str
-            if result.label == "":
-                test_link_text = f"`{test_path_str}`"
-            else:
-                test_link_text = f"`{test_path_str}` - {result.label}"
-            output.write(
-                f"| [{test_link_text}]({link_url})"
-                + f" | {marker}"
-                + f" | {mean_str}"
-                + f" | {max_str}"
-                + f" | {three_sigma_str}"
-                + f" | {limit_str}"
-                + f" | {percent_str}"
-                + " |\n"
-            )
-if __name__ == "__main__":
-    # pylint: disable = no-value-for-parameter
-    main()

tests/process_junit.py ADDED Viewed

         @@@ -1,0 -1,0 +1,349 @@@
+from __future__ import annotations
+import dataclasses
+import json
+import random
+from collections import defaultdict
+from dataclasses import dataclass, field
+from pathlib import Path
+from statistics import StatisticsError, mean, stdev
+from typing import Any, Dict, List, Optional, TextIO, Tuple, Type, final
+import click
+import lxml.etree
+from tests.util.misc import BenchmarkData, DataTypeProtocol, TestId
+from tests.util.time_out_assert import TimeOutAssertData
+supported_data_types: List[Type[DataTypeProtocol]] = [TimeOutAssertData, BenchmarkData]
+supported_data_types_by_tag: Dict[str, Type[DataTypeProtocol]] = {cls.tag: cls for cls in supported_data_types}
+@final
+@dataclass(frozen=True, order=True)
+class Result:
+    file_path: Path
+    test_path: Tuple[str, ...]
+    ids: Tuple[str, ...]
+    label: str
+    line: int = field(compare=False)
+    durations: Tuple[float, ...] = field(compare=False)
+    limit: float = field(compare=False)
+    def marshal(self) -> Dict[str, Any]:
+        return {
+            "file_path": self.file_path.as_posix(),
+            "test_path": self.test_path,
+            "label": self.label,
+            "duration": {
+                "all": self.durations,
+                "min": min(self.durations),
+                "max": max(self.durations),
+                "mean": mean(self.durations),
+            },
+        }
+    def link(self, prefix: str, line_separator: str) -> str:
+        return f"{prefix}{self.file_path.as_posix()}{line_separator}{self.line}"
+@final
+@dataclasses.dataclass(frozen=True)
+class EventId:
+    test_id: TestId
+    tag: str
+    line: int
+    path: Path
+    label: str
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.option(
+    "--xml",
+    "xml_file",
+    required=True,
+    type=click.File(),
+    help="The benchmarks JUnit XML results file",
+)
+@click.option(
+    "--link-prefix",
+    default="",
+    help="Prefix for output links such as for web links instead of IDE links",
+    show_default=True,
+)
+@click.option(
+    "--link-line-separator",
+    default=":",
+    help="The separator between the path and the line number, such as : for local links and #L on GitHub",
+    show_default=True,
+)
+@click.option(
+    "--output",
+    default="-",
+    type=click.File(mode="w", encoding="utf-8", lazy=True, atomic=True),
+    help="Output file, - for stdout",
+    show_default=True,
+)
+# TODO: anything but this pattern for output types
+@click.option(
+    "--markdown/--no-markdown",
+    help="Use markdown as output format",
+    show_default=True,
+)
+@click.option(
+    "--percent-margin",
+    default=15,
+    type=int,
+    help="Highlight results with maximums within this percent of the limit",
+    show_default=True,
+)
+@click.option(
+    "--randomoji/--determimoji",
+    help="≡ƒì┐",
+    show_default=True,
+)
+# TODO: subcommands?
+@click.option(
+    "--type",
+    "tag",
+    type=click.Choice([cls.tag for cls in supported_data_types]),
+    help="The type of data to process",
+    required=True,
+    show_default=True,
+)
+@click.option(
+    "--limit",
+    "result_count_limit",
+    type=int,
+    help="Limit the number of results to output.",
+)
+def main(
+    xml_file: TextIO,
+    link_prefix: str,
+    link_line_separator: str,
+    output: TextIO,
+    markdown: bool,
+    percent_margin: int,
+    randomoji: bool,
+    tag: str,
+    result_count_limit: Optional[int],
+) -> None:
+    data_type = supported_data_types_by_tag[tag]
+    tree = lxml.etree.parse(xml_file)
+    root = tree.getroot()
+    cases_by_test_id: defaultdict[TestId, List[lxml.etree.Element]] = defaultdict(list)
+    for suite in root.findall("testsuite"):
+        for case in suite.findall("testcase"):
+            if case.find("skipped") is not None:
+                continue
+            test_id_property = case.find("properties/property[@name='test_id']")
+            test_id = TestId.unmarshal(json.loads(test_id_property.attrib["value"]))
+            test_id = dataclasses.replace(
+                test_id, ids=tuple(id for id in test_id.ids if not id.startswith(f"{data_type.tag}_repeat"))
+            )
+            cases_by_test_id[test_id].append(case)
+    data_by_event_id: defaultdict[EventId, List[DataTypeProtocol]] = defaultdict(list)
+    for test_id, cases in cases_by_test_id.items():
+        for case in cases:
+            for property in case.findall(f"properties/property[@name='{tag}']"):
+                tag = property.attrib["name"]
+                data = supported_data_types_by_tag[tag].unmarshal(json.loads(property.attrib["value"]))
+                event_id = EventId(test_id=test_id, tag=tag, line=data.line, path=data.path, label=data.label)
+                data_by_event_id[event_id].append(data)
+    results: List[Result] = []
+    for event_id, datas in data_by_event_id.items():
+        [limit] = {data.limit for data in datas}
+        results.append(
+            Result(
+                file_path=event_id.path,
+                test_path=event_id.test_id.test_path,
+                ids=event_id.test_id.ids,
+                line=event_id.line,
+                durations=tuple(data.duration for data in datas),
+                limit=limit,
+                label=event_id.label,
+            )
+        )
+    if result_count_limit is not None:
+        results = sorted(results, key=lambda result: max(result.durations) / result.limit, reverse=True)
+        results = results[:result_count_limit]
+    handlers = {
+        BenchmarkData.tag: output_benchmark,
+        TimeOutAssertData.tag: output_time_out_assert,
+    }
+    handler = handlers[data_type.tag]
+    handler(
+        link_line_separator=link_line_separator,
+        link_prefix=link_prefix,
+        markdown=markdown,
+        output=output,
+        percent_margin=percent_margin,
+        randomoji=randomoji,
+        results=results,
+    )
+def output_benchmark(
+    link_line_separator: str,
+    link_prefix: str,
+    markdown: bool,
+    output: TextIO,
+    percent_margin: int,
+    randomoji: bool,
+    results: List[Result],
+) -> None:
+    if not markdown:
+        for result in sorted(results):
+            link = result.link(prefix=link_prefix, line_separator=link_line_separator)
+            dumped = json.dumps(result.marshal())
+            output.write(f"{link} {dumped}\n")
+    else:
+        output.write("# Benchmark Metrics\n\n")
+        output.write("| Test | ≡ƒì┐ | Mean | Max | 3╧â | Limit | Percent |\n")
+        output.write("| --- | --- | --- | --- | --- | --- | --- |\n")
+        for result in sorted(results):
+            link_url = result.link(prefix=link_prefix, line_separator=link_line_separator)
+            mean_str = "-"
+            three_sigma_str = "-"
+            if len(result.durations) > 1:
+                durations_mean = mean(result.durations)
+                mean_str = f"{durations_mean:.3f} s"
+                try:
+                    three_sigma_str = f"{durations_mean + 3 * stdev(result.durations):.3f} s"
+                except StatisticsError:
+                    pass
+            durations_max = max(result.durations)
+            max_str = f"{durations_max:.3f} s"
+            limit_str = f"{result.limit:.3f} s"
+            percent = 100 * durations_max / result.limit
+            if percent >= 100:
+                # intentionally biasing towards ≡ƒìä
+                choices = "≡ƒìä≡ƒìä≡ƒìÄ≡ƒìà"  # ≡ƒî╢∩╕Å≡ƒìë≡ƒìÆ≡ƒìô
+            elif percent >= (100 - percent_margin):
+                choices = "≡ƒìï≡ƒìî"  # ≡ƒìì≡ƒî╜
+            else:
+                choices = "≡ƒ½¢≡ƒìê≡ƒìÅ≡ƒìÉ≡ƒÑ¥≡ƒÑÆ≡ƒÑ¼≡ƒÑª"
+            marker: str
+            if randomoji:
+                marker = random.choice(choices)
+            else:
+                marker = choices[0]
+            percent_str = f"{percent:.0f} %"
+            test_path_str = ".".join(result.test_path[1:])
+            if len(result.ids) > 0:
+                test_path_str += f"[{'-'.join(result.ids)}]"
+            test_link_text: str
+            if result.label == "":
+                test_link_text = f"`{test_path_str}`"
+            else:
+                test_link_text = f"`{test_path_str}` - {result.label}"
+            output.write(
+                f"| [{test_link_text}]({link_url})"
+                + f" | {marker}"
+                + f" | {mean_str}"
+                + f" | {max_str}"
+                + f" | {three_sigma_str}"
+                + f" | {limit_str}"
+                + f" | {percent_str}"
+                + " |\n"
+            )
+def output_time_out_assert(
+    link_line_separator: str,
+    link_prefix: str,
+    markdown: bool,
+    output: TextIO,
+    percent_margin: int,
+    randomoji: bool,
+    results: List[Result],
+) -> None:
+    if not markdown:
+        for result in sorted(results):
+            link = result.link(prefix=link_prefix, line_separator=link_line_separator)
+            dumped = json.dumps(result.marshal())
+            output.write(f"{link} {dumped}\n")
+    else:
+        output.write("# Time Out Assert Metrics\n\n")
+        output.write("| Test | ≡ƒì┐ | Mean | Max | 3╧â | Limit | Percent |\n")
+        output.write("| --- | --- | --- | --- | --- | --- | --- |\n")
+        for result in sorted(results):
+            link_url = result.link(prefix=link_prefix, line_separator=link_line_separator)
+            mean_str = "-"
+            three_sigma_str = "-"
+            if len(result.durations) > 1:
+                durations_mean = mean(result.durations)
+                mean_str = f"{durations_mean:.3f} s"
+                try:
+                    three_sigma_str = f"{durations_mean + 3 * stdev(result.durations):.3f} s"
+                except StatisticsError:
+                    pass
+            durations_max = max(result.durations)
+            max_str = f"{durations_max:.3f} s"
+            limit_str = f"{result.limit:.3f} s"
+            percent = 100 * durations_max / result.limit
+            if percent >= 100:
+                # intentionally biasing towards ≡ƒìä
+                choices = "≡ƒìä≡ƒìä≡ƒìÄ≡ƒìà"  # ≡ƒî╢∩╕Å≡ƒìë≡ƒìÆ≡ƒìô
+            elif percent >= (100 - percent_margin):
+                choices = "≡ƒìï≡ƒìî"  # ≡ƒìì≡ƒî╜
+            else:
+                choices = "≡ƒ½¢≡ƒìê≡ƒìÅ≡ƒìÉ≡ƒÑ¥≡ƒÑÆ≡ƒÑ¼≡ƒÑª"
+            marker: str
+            if randomoji:
+                marker = random.choice(choices)
+            else:
+                marker = choices[0]
+            percent_str = f"{percent:.0f} %"
+            test_path_str = ".".join(result.test_path[1:])
+            if len(result.ids) > 0:
+                test_path_str += f"[{'-'.join(result.ids)}]"
+            test_link_text: str
+            if result.label == "":
+                # TODO: but could be in different files too
+                test_link_text = f"`{test_path_str}` - {result.line}"
+            else:
+                test_link_text = f"`{test_path_str}` - {result.label}"
+            output.write(
+                f"| [{test_link_text}]({link_url})"
+                + f" | {marker}"
+                + f" | {mean_str}"
+                + f" | {max_str}"
+                + f" | {three_sigma_str}"
+                + f" | {limit_str}"
+                + f" | {percent_str}"
+                + " |\n"
+            )
+if __name__ == "__main__":
+    # pylint: disable = no-value-for-parameter
+    main()
-- /dev/null
++ b/tests/rpc/__init__.py

tests/rpc/test_rpc_client.py RENAMED Viewed

         @@@ -1,0 -1,0 +1,49 @@@
+from __future__ import annotations
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Optional
+import pytest
+from chia.rpc.rpc_client import RpcClient
+from chia.util.ints import uint16
+from tests.util.misc import Marks, RecordingWebServer, datacases
+@dataclass
+class InvalidCreateCase:
+    id: str
+    root_path: Optional[Path] = None
+    net_config: Optional[Dict[str, Any]] = None
+    marks: Marks = ()
+@datacases(
+    InvalidCreateCase(id="just root path", root_path=Path("/root/path")),
+    InvalidCreateCase(id="just net config", net_config={}),
+)
+@pytest.mark.anyio
+async def test_rpc_client_create_raises_for_invalid_root_path_net_config_combinations(
+    case: InvalidCreateCase,
+) -> None:
+    with pytest.raises(ValueError, match="Either both or neither of"):
+        await RpcClient.create(
+            self_hostname="",
+            port=uint16(0),
+            root_path=case.root_path,
+            net_config=case.net_config,
+        )
+@pytest.mark.anyio
+async def test_rpc_client_works_without_ssl(recording_web_server: RecordingWebServer) -> None:
+    expected_result = {"success": True, "daddy": "putdown"}
+    async with RpcClient.create_as_context(
+        self_hostname=recording_web_server.web_server.hostname,
+        port=recording_web_server.web_server.listen_port,
+    ) as rpc_client:
+        result = await rpc_client.fetch(path="", request_json={"response": expected_result})
+    assert result == expected_result

tests/util/misc.py CHANGED Viewed

         @@@ -5,6 -5,6 +5,7 @@@ import dataclasse
 import enum
 import functools
 import gc
+import json
 import logging
 import os
 import pathlib
         @@@ -12,29 -11,23 +13,53 @@@ import ss
 import subprocess
 import sys
 from concurrent.futures import Future
-from inspect import getframeinfo, stack
+from dataclasses import dataclass, field
-from inspect import getframeinfo, stack
+from pathlib import Path
 from statistics import mean
 from textwrap import dedent
 from time import thread_time
 from types import TracebackType
-from typing import Any, Awaitable, Callable, Collection, Dict, Iterator, List, Optional, TextIO, Tuple, Type, Union
-from typing import Any, Callable, Collection, Iterator, List, Optional, TextIO, Tuple, Type, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+    ClassVar,
+    Collection,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Protocol,
+    TextIO,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+    final,
+)
+import aiohttp
 import pytest
+# TODO: update after resolution in https://github.com/pytest-dev/pytest/issues/7469
+from _pytest.nodes import Node
+from aiohttp import web
 from chia_rs import Coin
-from typing_extensions import Protocol, final
 import chia
+import tests
+from chia.full_node.mempool import Mempool
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.util.hash import std_hash
-from chia.util.ints import uint64
+from chia.util.ints import uint16, uint32, uint64
+from chia.util.misc import caller_file_and_line
+from chia.util.network import WebServer
 from chia.wallet.util.compute_hints import HintedCoin
+from chia.wallet.wallet_node import WalletNode
+from tests import ether
 from tests.core.data_layer.util import ChiaRoot
         @@@ -70,11 -63,11 +95,6 @@@ def manage_gc(mode: GcMode) -> Iterator
                 gc.disable()
-def caller_file_and_line(distance: int = 1) -> Tuple[str, int]:
-    caller = getframeinfo(stack()[distance + 1][0])
-    return caller.filename, caller.lineno
 @dataclasses.dataclass(frozen=True)
 class RuntimeResults:
     start: float
         @@@ -180,7 -173,7 +200,12 @@@ def measure_runtime
     overhead: Optional[float] = None,
     print_results: bool = True,
 ) -> Iterator[Future[RuntimeResults]]:
-    entry_file, entry_line = caller_file_and_line()
+    entry_file, entry_line = caller_file_and_line(
+        relative_to=(
+            pathlib.Path(chia.__file__).parent.parent,
+            pathlib.Path(tests.__file__).parent.parent,
+        )
+    )
     results_future: Future[RuntimeResults] = Future()
         @@@ -210,6 -203,6 +235,43 @@@
                 print(results.block(label=label))
+@final
+@dataclasses.dataclass(frozen=True)
+class BenchmarkData:
+    if TYPE_CHECKING:
+        _protocol_check: ClassVar[DataTypeProtocol] = cast("BenchmarkData", None)
+    tag: ClassVar[str] = "benchmark"
+    duration: float
+    path: pathlib.Path
+    line: int
+    limit: float
+    label: str
+    __match_args__: ClassVar[Tuple[str, ...]] = ()
+    @classmethod
+    def unmarshal(cls, marshalled: Dict[str, Any]) -> BenchmarkData:
+        return cls(
+            duration=marshalled["duration"],
+            path=pathlib.Path(marshalled["path"]),
+            line=int(marshalled["line"]),
+            limit=marshalled["limit"],
+            label=marshalled["label"],
+        )
+    def marshal(self) -> Dict[str, Any]:
+        return {
+            "duration": self.duration,
+            "path": self.path.as_posix(),
+            "line": self.line,
+            "limit": self.limit,
+            "label": self.label,
+        }
 @final
 @dataclasses.dataclass
 class _AssertRuntime:
         @@@ -236,6 -229,6 +298,7 @@@
     # https://github.com/pytest-dev/pytest/issues/2057
     seconds: float
+    # TODO: Optional?
     label: str = ""
     clock: Callable[[], float] = thread_time
     gc_mode: GcMode = GcMode.disable
         @@@ -247,10 -240,10 +310,14 @@@
     runtime_manager: Optional[contextlib.AbstractContextManager[Future[RuntimeResults]]] = None
     runtime_results_callable: Optional[Future[RuntimeResults]] = None
     enable_assertion: bool = True
-    record_property: Optional[Callable[[str, object], None]] = None
     def __enter__(self) -> Future[AssertRuntimeResults]:
-        self.entry_file, self.entry_line = caller_file_and_line()
+        self.entry_file, self.entry_line = caller_file_and_line(
+            relative_to=(
+                pathlib.Path(chia.__file__).parent.parent,
+                pathlib.Path(tests.__file__).parent.parent,
+            )
+        )
         self.runtime_manager = measure_runtime(
             clock=self.clock, gc_mode=self.gc_mode, overhead=self.overhead, print_results=False
         @@@ -290,16 -283,16 +357,19 @@@
         if self.print:
             print(results.block(label=self.label))
-        if self.record_property is not None:
-            self.record_property(f"duration:{self.label}", results.duration)
-            relative_path_str = (
-                pathlib.Path(results.entry_file).relative_to(pathlib.Path(chia.__file__).parent.parent).as_posix()
+        if ether.record_property is not None:
+            data = BenchmarkData(
+                duration=results.duration,
+                path=pathlib.Path(self.entry_file),
+                line=self.entry_line,
+                limit=self.seconds,
+                label=self.label,
             )
-            self.record_property(f"path:{self.label}", relative_path_str)
-            self.record_property(f"line:{self.label}", results.entry_line)
-            self.record_property(f"limit:{self.label}", self.seconds)
+            ether.record_property(  # pylint: disable=E1102
+                data.tag,
+                json.dumps(data.marshal(), ensure_ascii=True, sort_keys=True),
+            )
         if exc_type is None and self.enable_assertion:
             __tracebackhide__ = True
         @@@ -310,15 -303,15 +380,13 @@@
 @dataclasses.dataclass
 class BenchmarkRunner:
     enable_assertion: bool = True
-    label: Optional[str] = None
+    test_id: Optional[TestId] = None
     overhead: Optional[float] = None
-    record_property: Optional[Callable[[str, object], None]] = None
     @functools.wraps(_AssertRuntime)
     def assert_runtime(self, *args: Any, **kwargs: Any) -> _AssertRuntime:
         kwargs.setdefault("enable_assertion", self.enable_assertion)
         kwargs.setdefault("overhead", self.overhead)
-        kwargs.setdefault("record_property", self.record_property)
         return _AssertRuntime(*args, **kwargs)
         @@@ -414,73 -407,3 +482,153 @@@ def create_logger(file: TextIO = sys.st
     logger.addHandler(hdlr=stream_handler)
     return logger
+def invariant_check_mempool(mempool: Mempool) -> None:
+    with mempool._db_conn:
+        cursor = mempool._db_conn.execute("SELECT SUM(cost) FROM tx")
+        val = cursor.fetchone()[0]
+        if val is None:
+            val = 0
+    assert mempool._total_cost == val
+    with mempool._db_conn:
+        cursor = mempool._db_conn.execute("SELECT SUM(fee) FROM tx")
+        val = cursor.fetchone()[0]
+        if val is None:
+            val = 0
+    assert mempool._total_fee == val
+async def wallet_height_at_least(wallet_node: WalletNode, h: uint32) -> bool:
+    height = await wallet_node.wallet_state_manager.blockchain.get_finished_sync_up_to()
+    return height == h
+@final
+@dataclass
+class RecordingWebServer:
+    web_server: WebServer
+    requests: List[web.Request] = field(default_factory=list)
+    @classmethod
+    async def create(
+        cls,
+        hostname: str,
+        port: uint16,
+        max_request_body_size: int = 1024**2,  # Default `client_max_size` from web.Application
+        ssl_context: Optional[ssl.SSLContext] = None,
+        prefer_ipv6: bool = False,
+    ) -> RecordingWebServer:
+        web_server = await WebServer.create(
+            hostname=hostname,
+            port=port,
+            max_request_body_size=max_request_body_size,
+            ssl_context=ssl_context,
+            prefer_ipv6=prefer_ipv6,
+            start=False,
+        )
+        self = cls(web_server=web_server)
+        routes = [web.route(method="*", path=route, handler=func) for (route, func) in self.get_routes().items()]
+        web_server.add_routes(routes=routes)
+        await web_server.start()
+        return self
+    def get_routes(self) -> Dict[str, Callable[[web.Request], Awaitable[web.Response]]]:
+        return {"/{path:.*}": self.handler}
+    async def handler(self, request: web.Request) -> web.Response:
+        self.requests.append(request)
+        request_json = await request.json()
+        if isinstance(request_json, dict) and "response" in request_json:
+            response = request_json["response"]
+        else:
+            response = {"success": True}
+        return aiohttp.web.json_response(data=response)
+    async def await_closed(self) -> None:
+        self.web_server.close()
+        await self.web_server.await_closed()
+@final
+@dataclasses.dataclass(frozen=True)
+class TestId:
+    platform: str
+    test_path: Tuple[str, ...]
+    ids: Tuple[str, ...]
+    @classmethod
+    def create(cls, node: Node, platform: str = sys.platform) -> TestId:
+        test_path: List[str] = []
+        temp_node = node
+        while True:
+            name: str
+            if isinstance(temp_node, pytest.Function):
+                name = temp_node.originalname
+            elif isinstance(temp_node, pytest.Package):
+                # must check before pytest.Module since Package is a subclass
+                name = temp_node.name
+            elif isinstance(temp_node, pytest.Module):
+                name = temp_node.name[:-3]
+            else:
+                name = temp_node.name
+            test_path.insert(0, name)
+            if isinstance(temp_node.parent, pytest.Session) or temp_node.parent is None:
+                break
+            temp_node = temp_node.parent
+        # TODO: can we avoid parsing the id's etc from the node name?
+        test_name, delimiter, rest = node.name.partition("[")
+        ids: Tuple[str, ...]
+        if delimiter == "":
+            ids = ()
+        else:
+            ids = tuple(rest.rstrip("]").split("-"))
+        return cls(
+            platform=platform,
+            test_path=tuple(test_path),
+            ids=ids,
+        )
+    @classmethod
+    def unmarshal(cls, marshalled: Dict[str, Any]) -> TestId:
+        return cls(
+            platform=marshalled["platform"],
+            test_path=tuple(marshalled["test_path"]),
+            ids=tuple(marshalled["ids"]),
+        )
+    def marshal(self) -> Dict[str, Any]:
+        return {
+            "platform": self.platform,
+            "test_path": self.test_path,
+            "ids": self.ids,
+        }
+T = TypeVar("T")
+@dataclasses.dataclass(frozen=True)
+class DataTypeProtocol(Protocol):
+    tag: ClassVar[str]
+    line: int
+    path: Path
+    label: str
+    duration: float
+    limit: float
+    __match_args__: ClassVar[Tuple[str, ...]] = ()
+    @classmethod
+    def unmarshal(cls: Type[T], marshalled: Dict[str, Any]) -> T:
+        ...
+    def marshal(self) -> Dict[str, Any]:
+        ...

tests/util/test_condition_tools.py CHANGED Viewed

         @@@ -15,6 -15,6 +15,7 @@@ from chia.types.spend_bundle_condition
 from chia.util.condition_tools import parse_sexp_to_conditions, pkm_pairs, pkm_pairs_for_conditions_dict
 from chia.util.errors import ConsensusError
 from chia.util.hash import std_hash
+from chia.util.ints import uint64
 H1 = bytes32(b"a" * 32)
 H2 = bytes32(b"b" * 32)
         @@@ -23,7 -23,7 +24,7 @@@ H3 = bytes32(b"c" * 32
 PK1 = G1Element.generator()
 PK2 = G1Element.generator()
-TEST_COIN = Coin(H1, H2, 123)
+TEST_COIN = Coin(H1, H2, uint64(123))
 def mk_agg_sig_conditions(

tests/util/test_misc.py CHANGED Viewed

         @@@ -1,19 -1,16 +1,22 @@@
 from __future__ import annotations
 import contextlib
-from typing import AsyncIterator, Iterator, List, Optional, TypeVar
-from typing import AsyncIterator, Iterator, List
+from typing import AsyncIterator, Iterator, List, Optional, Tuple, Type, TypeVar
+import aiohttp
+import anyio
 import pytest
+from chia.types.blockchain_format.program import Program
 from chia.util.errors import InvalidPathError
+from chia.util.ints import uint64
 from chia.util.misc import (
     SplitAsyncManager,
     SplitManager,
+    ValuedEvent,
     format_bytes,
     format_minutes,
+    satisfies_hint,
     split_async_manager,
     split_manager,
     to_batches,
         @@@ -313,118 -306,3 +316,139 @@@ async def test_split_async_manager_rais
     with pytest.raises(Exception, match="^not yet entered$"):
         await split.exit()
+async def wait_for_valued_event_waiters(
+    event: ValuedEvent[T],
+    count: int,
+    timeout: float = 10,
+) -> None:
+    with anyio.fail_after(delay=adjusted_timeout(timeout)):
+        for delay in backoff_times():
+            # ignoring the type since i'm hacking into the private attribute
+            # hopefully this is ok for testing and if it becomes invalid we
+            # will end up with an exception and can adjust then
+            if len(event._event._waiters) >= count:  # type: ignore[attr-defined]
+                return
+            await anyio.sleep(delay)
+@pytest.mark.anyio
+async def test_valued_event_wait_already_set() -> None:
+    valued_event = ValuedEvent[int]()
+    value = 37
+    valued_event.set(value)
+    with anyio.fail_after(adjusted_timeout(10)):
+        result = await valued_event.wait()
+    assert result == value
+@pytest.mark.anyio
+async def test_valued_event_wait_not_yet_set() -> None:
+    valued_event = ValuedEvent[int]()
+    value = 37
+    result: Optional[int] = None
+    async def wait(valued_event: ValuedEvent[int]) -> None:
+        nonlocal result
+        result = await valued_event.wait()
+    with anyio.fail_after(adjusted_timeout(10)):
+        async with anyio.create_task_group() as task_group:
+            task_group.start_soon(wait, valued_event)
+            await wait_for_valued_event_waiters(event=valued_event, count=1)
+            valued_event.set(value)
+    assert result == value
+@pytest.mark.anyio
+async def test_valued_event_wait_blocks_when_not_set() -> None:
+    valued_event = ValuedEvent[int]()
+    with pytest.raises(TimeoutError):
+        # if we could just process until there are no pending events, that would be great
+        with anyio.fail_after(adjusted_timeout(1)):
+            await valued_event.wait()
+@pytest.mark.anyio
+async def test_valued_event_multiple_waits_all_get_values() -> None:
+    results: List[int] = []
+    valued_event = ValuedEvent[int]()
+    value = 37
+    task_count = 10
+    async def wait_and_append() -> None:
+        results.append(await valued_event.wait())
+    async with anyio.create_task_group() as task_group:
+        for i in range(task_count):
+            task_group.start_soon(wait_and_append, name=f"wait_and_append_{i}")
+        await wait_for_valued_event_waiters(event=valued_event, count=task_count)
+        valued_event.set(value)
+    assert results == [value] * task_count
+@pytest.mark.anyio
+async def test_valued_event_set_again_raises_and_does_not_change_value() -> None:
+    valued_event = ValuedEvent[int]()
+    value = 37
+    valued_event.set(value)
+    with pytest.raises(Exception, match="^Value already set$"):
+        valued_event.set(value + 1)
+    with anyio.fail_after(adjusted_timeout(10)):
+        result = await valued_event.wait()
+    assert result == value
+@pytest.mark.anyio
+async def test_valued_event_wait_raises_if_not_set() -> None:
+    valued_event = ValuedEvent[int]()
+    valued_event._event.set()
+    with pytest.raises(Exception, match="^Value not set despite event being set$"):
+        with anyio.fail_after(adjusted_timeout(10)):
+            await valued_event.wait()
+@pytest.mark.anyio
+async def test_recording_web_server_specified_response(
+    recording_web_server: RecordingWebServer,
+) -> None:
+    expected_response = {"success": True, "magic": "asparagus"}
+    async with aiohttp.ClientSession() as session:
+        async with session.post(
+            url=recording_web_server.web_server.url(),
+            json={"response": expected_response},
+        ) as response:
+            response.raise_for_status()
+            assert await response.json() == expected_response
+@pytest.mark.parametrize(
+    "obj, type_hint, expected_result",
+    [
+        (42, int, True),
+        (42, uint64, False),
+        (uint64(42), uint64, True),
+        ("42", int, False),
+        ([4, 2], List[int], True),
+        ([4, "2"], List[int], False),
+        ((4, 2), Tuple[int, int], True),
+        ((4, "2"), Tuple[int, int], False),
+        ((4, 2), Tuple[int, ...], True),
+        ((4, "2"), Tuple[int, ...], False),
+        ([(4, Program.to([2]))], List[Tuple[int, Program]], True),
+        ([(4, "2")], Tuple[int, str], False),
+    ],
+)
+def test_satisfies_hint(obj: T, type_hint: Type[T], expected_result: bool) -> None:
+    assert satisfies_hint(obj, type_hint) == expected_result

tests/util/time_out_assert.py CHANGED Viewed

         @@@ -1,39 -1,39 +1,130 @@@
 from __future__ import annotations
 import asyncio
+import dataclasses
+import json
 import logging
+import pathlib
 import time
-from typing import Callable
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Dict, Tuple, cast, final
+import chia
+import tests
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.util.misc import caller_file_and_line
 from chia.util.timing import adjusted_timeout
+from tests import ether
+from tests.util.misc import DataTypeProtocol
 log = logging.getLogger(__name__)
-async def time_out_assert_custom_interval(timeout: float, interval, function, value=True, *args, **kwargs):
+@final
+@dataclasses.dataclass(frozen=True)
+class TimeOutAssertData:
+    if TYPE_CHECKING:
+        _protocol_check: ClassVar[DataTypeProtocol] = cast("TimeOutAssertData", None)
+    tag: ClassVar[str] = "time_out_assert"
+    duration: float
+    path: pathlib.Path
+    line: int
+    limit: float
+    timed_out: bool
+    label: str = ""
+    __match_args__: ClassVar[Tuple[str, ...]] = ()
+    @classmethod
+    def unmarshal(cls, marshalled: Dict[str, Any]) -> TimeOutAssertData:
+        return cls(
+            duration=marshalled["duration"],
+            path=pathlib.Path(marshalled["path"]),
+            line=int(marshalled["line"]),
+            limit=marshalled["limit"],
+            timed_out=marshalled["timed_out"],
+        )
+    def marshal(self) -> Dict[str, Any]:
+        return {
+            "duration": self.duration,
+            "path": self.path.as_posix(),
+            "line": self.line,
+            "limit": self.limit,
+            "timed_out": self.timed_out,
+        }
+async def time_out_assert_custom_interval(
+    timeout: float, interval, function, value=True, *args, stack_distance=0, **kwargs
+):
     __tracebackhide__ = True
+    entry_file, entry_line = caller_file_and_line(
+        distance=stack_distance + 1,
+        relative_to=(
+            pathlib.Path(chia.__file__).parent.parent,
+            pathlib.Path(tests.__file__).parent.parent,
+        ),
+    )
     timeout = adjusted_timeout(timeout=timeout)
-    start = time.time()
-    while time.time() - start < timeout:
-        if asyncio.iscoroutinefunction(function):
-            f_res = await function(*args, **kwargs)
-        else:
-            f_res = function(*args, **kwargs)
-        if value == f_res:
-            return None
-        await asyncio.sleep(interval)
-    assert False, f"Timed assertion timed out after {timeout} seconds: expected {value!r}, got {f_res!r}"
+    start = time.monotonic()
+    duration = 0.0
+    timed_out = False
+    try:
+        while True:
+            if asyncio.iscoroutinefunction(function):
+                f_res = await function(*args, **kwargs)
+            else:
+                f_res = function(*args, **kwargs)
+            if value == f_res:
+                return None
+            now = time.monotonic()
+            duration = now - start
+            if duration > timeout:
+                timed_out = True
+                assert False, f"Timed assertion timed out after {timeout} seconds: expected {value!r}, got {f_res!r}"
+            await asyncio.sleep(min(interval, timeout - duration))
+    finally:
+        if ether.record_property is not None:
+            data = TimeOutAssertData(
+                duration=duration,
+                path=pathlib.Path(entry_file),
+                line=entry_line,
+                limit=timeout,
+                timed_out=timed_out,
+            )
+            ether.record_property(  # pylint: disable=E1102
+                data.tag,
+                json.dumps(data.marshal(), ensure_ascii=True, sort_keys=True),
+            )
 async def time_out_assert(timeout: int, function, value=True, *args, **kwargs):
     __tracebackhide__ = True
-    await time_out_assert_custom_interval(timeout, 0.05, function, value, *args, **kwargs)
+    await time_out_assert_custom_interval(
+        timeout,
+        0.05,
+        function,
+        value,
+        *args,
+        **kwargs,
+        stack_distance=1,
+    )
 async def time_out_assert_not_none(timeout: float, function, *args, **kwargs):
+    # TODO: rework to leverage time_out_assert_custom_interval() such as by allowing
+    #       value to be a callable
     __tracebackhide__ = True
     timeout = adjusted_timeout(timeout=timeout)

tests/wallet/cat_wallet/test_cat_wallet.py CHANGED Viewed

         @@@ -38,952 -39,1016 +38,910 @@@ from tests.util.setup_nodes import OldS
 from tests.util.time_out_assert import time_out_assert, time_out_assert_not_none
-class TestCATWallet:
-    @pytest.mark.parametrize(
-        "trusted",
-        [True, False],
-    )
-    @pytest.mark.anyio
-    async def test_cat_creation(self, self_hostname, two_wallet_nodes, trusted):
-        num_blocks = 3
-        full_nodes, wallets, _ = two_wallet_nodes
-        full_node_api = full_nodes[0]
-        full_node_server = full_node_api.server
-        wallet_node, server_2 = wallets[0]
-        wallet = wallet_node.wallet_state_manager.main_wallet
-        ph = await wallet.get_new_puzzlehash()
-        if trusted:
-            wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-        else:
-            wallet_node.config["trusted_peers"] = {}
-        await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        for i in range(0, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
-        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(32 * b"0"))
-        funds = sum(
-            [
-                calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
-                for i in range(1, num_blocks + 1)
-            ]
-        )
+def check_wallets(node: WalletNode) -> int:
+    return len(node.wallet_state_manager.wallets.keys())
-        await time_out_assert(20, wallet.get_confirmed_balance, funds)
-        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
-        async with wallet_node.wallet_state_manager.lock:
-            cat_wallet, _ = await CATWallet.create_new_cat_wallet(
-                wallet_node.wallet_state_manager,
-                wallet,
-                {"identifier": "genesis_by_id"},
-                uint64(100),
-                DEFAULT_TX_CONFIG,
-                fee=uint64(10),
-            )
-            # The next 2 lines are basically a noop, it just adds test coverage
-            cat_wallet = await CATWallet.create(wallet_node.wallet_state_manager, wallet, cat_wallet.wallet_info)
-            await wallet_node.wallet_state_manager.add_new_wallet(cat_wallet)
-        tx_queue: List[TransactionRecord] = await wallet_node.wallet_state_manager.tx_store.get_not_sent()
-        tx_record = tx_queue[0]
-        await full_node_api.process_transaction_records(records=[tx_record])
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 100)
-        await time_out_assert(20, cat_wallet.get_spendable_balance, 100)
-        await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 100)
-        await time_out_assert(20, wallet.get_confirmed_balance, funds - 110)
-        await time_out_assert(20, wallet.get_spendable_balance, funds - 110)
-        await time_out_assert(20, wallet.get_unconfirmed_balance, funds - 110)
-        # Test migration
-        all_lineage = await cat_wallet.lineage_store.get_all_lineage_proofs()
-        current_info = cat_wallet.wallet_info
-        data_str = bytes(
-            LegacyCATInfo(
-                cat_wallet.cat_info.limitations_program_hash, cat_wallet.cat_info.my_tail, list(all_lineage.items())
-            )
-        ).hex()
-        wallet_info = WalletInfo(current_info.id, current_info.name, current_info.type, data_str)
-        new_cat_wallet = await CATWallet.create(wallet_node.wallet_state_manager, wallet, wallet_info)
-        assert new_cat_wallet.cat_info.limitations_program_hash == cat_wallet.cat_info.limitations_program_hash
-        assert new_cat_wallet.cat_info.my_tail == cat_wallet.cat_info.my_tail
-        assert await cat_wallet.lineage_store.get_all_lineage_proofs() == all_lineage
-        height = full_node_api.full_node.blockchain.get_peak_height()
-        await full_node_api.reorg_from_index_to_new_index(
-            ReorgProtocol(height - num_blocks - 1, height + 1, 32 * b"1", None)
-        )
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 0)
-    @pytest.mark.anyio
-    async def test_cat_creation_unique_lineage_store(self, self_hostname, two_wallet_nodes):
-        num_blocks = 3
-        full_nodes, wallets, _ = two_wallet_nodes
-        full_node_api = full_nodes[0]
-        full_node_server = full_node_api.server
-        wallet_node, wallet_server = wallets[0]
-        wallet = wallet_node.wallet_state_manager.main_wallet
-        ph = await wallet.get_new_puzzlehash()
+@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.anyio
+async def test_cat_creation(self_hostname: str, two_wallet_nodes: OldSimulatorsAndWallets, trusted: bool) -> None:
+    num_blocks = 3
+    full_nodes, wallets, _ = two_wallet_nodes
+    full_node_api = full_nodes[0]
+    full_node_server = full_node_api.server
+    wallet_node, server_2 = wallets[0]
+    wallet = wallet_node.wallet_state_manager.main_wallet
+    ph = await wallet.get_new_puzzlehash()
+    if trusted:
         wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+    else:
+        wallet_node.config["trusted_peers"] = {}
-        await wallet_server.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        for i in range(0, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
-        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(32 * b"0"))
+    await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    for _ in range(num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32(32 * b"0")))
-        funds = sum(
-            [
-                calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
-                for i in range(1, num_blocks + 1)
-            ]
-        )
+    funds = sum(
+        [calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks + 1)]
+    )
-        await time_out_assert(20, wallet.get_confirmed_balance, funds)
-        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
-        async with wallet_node.wallet_state_manager.lock:
-            cat_wallet_1, _ = await CATWallet.create_new_cat_wallet(
-                wallet_node.wallet_state_manager,
-                wallet,
-                {"identifier": "genesis_by_id"},
-                uint64(100),
-                DEFAULT_TX_CONFIG,
-            )
-            cat_wallet_2, _ = await CATWallet.create_new_cat_wallet(
-                wallet_node.wallet_state_manager,
-                wallet,
-                {"identifier": "genesis_by_id"},
-                uint64(200),
-                DEFAULT_TX_CONFIG,
-            )
-        proofs_1 = await cat_wallet_1.lineage_store.get_all_lineage_proofs()
-        proofs_2 = await cat_wallet_2.lineage_store.get_all_lineage_proofs()
-        assert len(proofs_1) == len(proofs_2)
-        assert proofs_1 != proofs_2
-        assert cat_wallet_1.lineage_store.table_name != cat_wallet_2.lineage_store.table_name
-    @pytest.mark.parametrize(
-        "trusted",
-        [True, False],
+    await time_out_assert(20, wallet.get_confirmed_balance, funds)
+    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
+    async with wallet_node.wallet_state_manager.lock:
-        cat_wallet, _ = await CATWallet.create_new_cat_wallet(
+        cat_wallet, tx_records = await CATWallet.create_new_cat_wallet(
+            wallet_node.wallet_state_manager,
+            wallet,
+            {"identifier": "genesis_by_id"},
+            uint64(100),
+            DEFAULT_TX_CONFIG,
+            fee=uint64(10),
+        )
+        # The next 2 lines are basically a noop, it just adds test coverage
+        cat_wallet = await CATWallet.create(wallet_node.wallet_state_manager, wallet, cat_wallet.wallet_info)
+        await wallet_node.wallet_state_manager.add_new_wallet(cat_wallet)
-    tx_queue = await wallet_node.wallet_state_manager.tx_store.get_not_sent()
-    tx_record = tx_queue[0]
-    await full_node_api.process_transaction_records(records=[tx_record])
+    await full_node_api.process_transaction_records(records=tx_records)
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 100)
+    await time_out_assert(20, cat_wallet.get_spendable_balance, 100)
+    await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 100)
+    await time_out_assert(20, wallet.get_confirmed_balance, funds - 110)
+    await time_out_assert(20, wallet.get_spendable_balance, funds - 110)
+    await time_out_assert(20, wallet.get_unconfirmed_balance, funds - 110)
+    # Test migration
+    all_lineage = await cat_wallet.lineage_store.get_all_lineage_proofs()
+    current_info = cat_wallet.wallet_info
+    data_str = bytes(
+        LegacyCATInfo(
+            cat_wallet.cat_info.limitations_program_hash, cat_wallet.cat_info.my_tail, list(all_lineage.items())
+        )
+    ).hex()
+    wallet_info = WalletInfo(current_info.id, current_info.name, current_info.type, data_str)
+    new_cat_wallet = await CATWallet.create(wallet_node.wallet_state_manager, wallet, wallet_info)
+    assert new_cat_wallet.cat_info.limitations_program_hash == cat_wallet.cat_info.limitations_program_hash
+    assert new_cat_wallet.cat_info.my_tail == cat_wallet.cat_info.my_tail
+    assert await cat_wallet.lineage_store.get_all_lineage_proofs() == all_lineage
+    height = full_node_api.full_node.blockchain.get_peak_height()
+    assert height is not None
+    await full_node_api.reorg_from_index_to_new_index(
+        ReorgProtocol(uint32(height - num_blocks - 1), uint32(height + 1), bytes32(32 * b"1"), None)
     )
-    @pytest.mark.anyio
-    async def test_cat_spend(self, self_hostname, two_wallet_nodes, trusted):
-        num_blocks = 3
-        full_nodes, wallets, _ = two_wallet_nodes
-        full_node_api = full_nodes[0]
-        full_node_server = full_node_api.server
-        wallet_node, server_2 = wallets[0]
-        wallet_node_2, server_3 = wallets[1]
-        wallet = wallet_node.wallet_state_manager.main_wallet
-        wallet2 = wallet_node_2.wallet_state_manager.main_wallet
-        api_0 = WalletRpcApi(wallet_node)
-        api_1 = WalletRpcApi(wallet_node_2)
-        ph = await wallet.get_new_puzzlehash()
-        if trusted:
-            wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-            wallet_node_2.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-        else:
-            wallet_node.config["trusted_peers"] = {}
-            wallet_node_2.config["trusted_peers"] = {}
-        await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        await server_3.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        for i in range(0, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
-        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(32 * b"0"))
-        funds = sum(
-            [
-                calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
-                for i in range(1, num_blocks + 1)
-            ]
-        )
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 0)
-        await time_out_assert(20, wallet.get_confirmed_balance, funds)
-        async with wallet_node.wallet_state_manager.lock:
-            cat_wallet, _ = await CATWallet.create_new_cat_wallet(
-                wallet_node.wallet_state_manager,
-                wallet,
-                {"identifier": "genesis_by_id"},
-                uint64(100),
-                DEFAULT_TX_CONFIG,
-            )
-        tx_queue: List[TransactionRecord] = await wallet_node.wallet_state_manager.tx_store.get_not_sent()
-        tx_record = tx_queue[0]
-        await full_node_api.process_transaction_records(records=[tx_record])
+@pytest.mark.anyio
+async def test_cat_creation_unique_lineage_store(self_hostname: str, two_wallet_nodes: OldSimulatorsAndWallets) -> None:
+    num_blocks = 3
+    full_nodes, wallets, _ = two_wallet_nodes
+    full_node_api = full_nodes[0]
+    full_node_server = full_node_api.server
+    wallet_node, wallet_server = wallets[0]
+    wallet = wallet_node.wallet_state_manager.main_wallet
+    ph = await wallet.get_new_puzzlehash()
+    wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+    await wallet_server.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    for _ in range(num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32(32 * b"0")))
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 100)
-        await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 100)
+    funds = sum(
+        [calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks + 1)]
+    )
-        assert cat_wallet.cat_info.limitations_program_hash is not None
-        asset_id = cat_wallet.get_asset_id()
+    await time_out_assert(20, wallet.get_confirmed_balance, funds)
+    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
-        cat_wallet_2: CATWallet = await CATWallet.get_or_create_wallet_for_cat(
-            wallet_node_2.wallet_state_manager, wallet2, asset_id
+    async with wallet_node.wallet_state_manager.lock:
+        cat_wallet_1, _ = await CATWallet.create_new_cat_wallet(
-            wallet_node.wallet_state_manager,
-            wallet,
-            {"identifier": "genesis_by_id"},
-            uint64(100),
-            DEFAULT_TX_CONFIG,
+            wallet_node.wallet_state_manager, wallet, {"identifier": "genesis_by_id"}, uint64(100), DEFAULT_TX_CONFIG
+        )
+        cat_wallet_2, _ = await CATWallet.create_new_cat_wallet(
-            wallet_node.wallet_state_manager,
-            wallet,
-            {"identifier": "genesis_by_id"},
-            uint64(200),
-            DEFAULT_TX_CONFIG,
+            wallet_node.wallet_state_manager, wallet, {"identifier": "genesis_by_id"}, uint64(200), DEFAULT_TX_CONFIG
         )
-        assert cat_wallet.cat_info.limitations_program_hash == cat_wallet_2.cat_info.limitations_program_hash
+    proofs_1 = await cat_wallet_1.lineage_store.get_all_lineage_proofs()
+    proofs_2 = await cat_wallet_2.lineage_store.get_all_lineage_proofs()
+    assert len(proofs_1) == len(proofs_2)
+    assert proofs_1 != proofs_2
+    assert cat_wallet_1.lineage_store.table_name != cat_wallet_2.lineage_store.table_name
-        cat_2_hash = await cat_wallet_2.get_new_inner_hash()
-        tx_records = await cat_wallet.generate_signed_transaction(
-            [uint64(60)], [cat_2_hash], DEFAULT_TX_CONFIG, fee=uint64(1)
-        )
-        tx_id = None
-        await wallet.wallet_state_manager.add_pending_transactions(tx_records)
-        for tx_record in tx_records:
-            if tx_record.wallet_id is cat_wallet.id():
-                tx_id = tx_record.name.hex()
-                assert tx_record.to_puzzle_hash == cat_2_hash
-        await time_out_assert(15, full_node_api.txs_in_mempool, True, tx_records)
-        await time_out_assert(20, cat_wallet.get_pending_change_balance, 40)
-        memos = await api_0.get_transaction_memo(dict(transaction_id=tx_id))
-        assert len(memos[tx_id]) == 2  # One for tx, one for change
-        assert list(memos[tx_id].values())[0][0] == cat_2_hash.hex()
-        for i in range(1, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(32 * b"\0"))
-        await time_out_assert(30, wallet.get_confirmed_balance, funds - 101)
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 40)
-        await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 40)
-        await time_out_assert(30, cat_wallet_2.get_confirmed_balance, 60)
-        await time_out_assert(30, cat_wallet_2.get_unconfirmed_balance, 60)
-        coins = await cat_wallet_2.select_coins(uint64(60), DEFAULT_COIN_SELECTION_CONFIG)
-        assert len(coins) == 1
-        coin = coins.pop()
-        tx_id = coin.name().hex()
-        memos = await api_1.get_transaction_memo(dict(transaction_id=tx_id))
-        assert len(memos[tx_id]) == 2
-        assert list(memos[tx_id].values())[0][0] == cat_2_hash.hex()
-        cat_hash = await cat_wallet.get_new_inner_hash()
-        tx_records = await cat_wallet_2.generate_signed_transaction([uint64(15)], [cat_hash], DEFAULT_TX_CONFIG)
-        await wallet.wallet_state_manager.add_pending_transactions(tx_records)
-        await time_out_assert(15, full_node_api.txs_in_mempool, True, tx_records)
+@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.anyio
+async def test_cat_spend(self_hostname: str, two_wallet_nodes: OldSimulatorsAndWallets, trusted: bool) -> None:
+    num_blocks = 3
+    full_nodes, wallets, _ = two_wallet_nodes
+    full_node_api = full_nodes[0]
+    full_node_server = full_node_api.server
+    wallet_node, server_2 = wallets[0]
+    wallet_node_2, server_3 = wallets[1]
+    wallet = wallet_node.wallet_state_manager.main_wallet
+    wallet2 = wallet_node_2.wallet_state_manager.main_wallet
+    api_0 = WalletRpcApi(wallet_node)
+    api_1 = WalletRpcApi(wallet_node_2)
+    ph = await wallet.get_new_puzzlehash()
+    if trusted:
+        wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+        wallet_node_2.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+    else:
+        wallet_node.config["trusted_peers"] = {}
+        wallet_node_2.config["trusted_peers"] = {}
+    await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    await server_3.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    for _ in range(num_blocks):
         await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32(32 * b"0")))
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 55)
-        await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 55)
+    funds = sum(
+        [calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks + 1)]
+    )
-        height = full_node_api.full_node.blockchain.get_peak_height()
-        await full_node_api.reorg_from_index_to_new_index(ReorgProtocol(height - 1, height + 1, 32 * b"1", None))
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 40)
+    await time_out_assert(20, wallet.get_confirmed_balance, funds)
-    @pytest.mark.parametrize(
-        "trusted",
-        [True, False],
-    )
-    @pytest.mark.anyio
-    async def test_cat_reuse_address(self, self_hostname, two_wallet_nodes, trusted):
-        num_blocks = 3
-        full_nodes, wallets, _ = two_wallet_nodes
-        full_node_api = full_nodes[0]
-        full_node_server = full_node_api.server
-        wallet_node, server_2 = wallets[0]
-        wallet_node_2, server_3 = wallets[1]
-        wallet = wallet_node.wallet_state_manager.main_wallet
-        wallet2 = wallet_node_2.wallet_state_manager.main_wallet
-        ph = await wallet.get_new_puzzlehash()
-        if trusted:
-            wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-            wallet_node_2.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-        else:
-            wallet_node.config["trusted_peers"] = {}
-            wallet_node_2.config["trusted_peers"] = {}
-        await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        await server_3.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        for i in range(0, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
-        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(32 * b"0"))
-        funds = sum(
-            [
-                calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
-                for i in range(1, num_blocks + 1)
-            ]
+    async with wallet_node.wallet_state_manager.lock:
-        cat_wallet, _ = await CATWallet.create_new_cat_wallet(
-            wallet_node.wallet_state_manager,
-            wallet,
-            {"identifier": "genesis_by_id"},
-            uint64(100),
-            DEFAULT_TX_CONFIG,
+        cat_wallet, tx_records = await CATWallet.create_new_cat_wallet(
+            wallet_node.wallet_state_manager, wallet, {"identifier": "genesis_by_id"}, uint64(100), DEFAULT_TX_CONFIG
         )
-    tx_queue = await wallet_node.wallet_state_manager.tx_store.get_not_sent()
-    tx_record = tx_queue[0]
-    await full_node_api.process_transaction_records(records=[tx_record])
+    await full_node_api.process_transaction_records(records=tx_records)
-        await time_out_assert(20, wallet.get_confirmed_balance, funds)
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 100)
+    await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 100)
-        async with wallet_node.wallet_state_manager.lock:
-            cat_wallet, _ = await CATWallet.create_new_cat_wallet(
-                wallet_node.wallet_state_manager,
-                wallet,
-                {"identifier": "genesis_by_id"},
-                uint64(100),
-                DEFAULT_TX_CONFIG,
-            )
-        tx_queue: List[TransactionRecord] = await wallet_node.wallet_state_manager.tx_store.get_not_sent()
-        tx_record = tx_queue[0]
-        await full_node_api.process_transaction_records(records=[tx_record])
+    assert cat_wallet.cat_info.limitations_program_hash is not None
+    asset_id = cat_wallet.get_asset_id()
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 100)
-        await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 100)
+    cat_wallet_2 = await CATWallet.get_or_create_wallet_for_cat(wallet_node_2.wallet_state_manager, wallet2, asset_id)
-        assert cat_wallet.cat_info.limitations_program_hash is not None
-        asset_id = cat_wallet.get_asset_id()
+    assert cat_wallet.cat_info.limitations_program_hash == cat_wallet_2.cat_info.limitations_program_hash
+    cat_2_hash = await cat_wallet_2.get_new_inner_hash()
+    tx_records = await cat_wallet.generate_signed_transaction(
+        [uint64(60)], [cat_2_hash], DEFAULT_TX_CONFIG, fee=uint64(1)
+    )
+    tx_id = None
+    tx_records = await wallet.wallet_state_manager.add_pending_transactions(tx_records)
+    for tx_record in tx_records:
+        if tx_record.wallet_id is cat_wallet.id():
+            tx_id = tx_record.name.hex()
+            assert tx_record.to_puzzle_hash == cat_2_hash
+    await time_out_assert(15, full_node_api.txs_in_mempool, True, tx_records)
+    await time_out_assert(20, cat_wallet.get_pending_change_balance, 40)
+    assert tx_id is not None
+    memos = await api_0.get_transaction_memo({"transaction_id": tx_id})
+    assert len(memos[tx_id]) == 2  # One for tx, one for change
+    assert list(memos[tx_id].values())[0][0] == cat_2_hash.hex()
+    for _ in range(1, num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32(32 * b"\0")))
+    await time_out_assert(30, wallet.get_confirmed_balance, funds - 101)
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 40)
+    await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 40)
+    await time_out_assert(30, cat_wallet_2.get_confirmed_balance, 60)
+    await time_out_assert(30, cat_wallet_2.get_unconfirmed_balance, 60)
+    coins = await cat_wallet_2.select_coins(uint64(60), DEFAULT_COIN_SELECTION_CONFIG)
+    assert len(coins) == 1
+    coin = coins.pop()
+    tx_id = coin.name().hex()
+    memos = await api_1.get_transaction_memo(dict(transaction_id=tx_id))
+    assert len(memos[tx_id]) == 2
+    assert list(memos[tx_id].values())[0][0] == cat_2_hash.hex()
+    cat_hash = await cat_wallet.get_new_inner_hash()
+    tx_records = await cat_wallet_2.generate_signed_transaction([uint64(15)], [cat_hash], DEFAULT_TX_CONFIG)
+    tx_records = await wallet2.wallet_state_manager.add_pending_transactions(tx_records)
+    await time_out_assert(15, full_node_api.txs_in_mempool, True, tx_records)
+    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 55)
+    await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 55)
+    height = full_node_api.full_node.blockchain.get_peak_height()
+    assert height is not None
+    await full_node_api.reorg_from_index_to_new_index(
+        ReorgProtocol(uint32(height - 1), uint32(height + 1), bytes32(32 * b"1"), None)
+    )
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 40)
-        cat_wallet_2: CATWallet = await CATWallet.get_or_create_wallet_for_cat(
-            wallet_node_2.wallet_state_manager, wallet2, asset_id
-        )
-        assert cat_wallet.cat_info.limitations_program_hash == cat_wallet_2.cat_info.limitations_program_hash
+@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.anyio
+async def test_cat_reuse_address(self_hostname: str, two_wallet_nodes: OldSimulatorsAndWallets, trusted: bool) -> None:
+    num_blocks = 3
+    full_nodes, wallets, _ = two_wallet_nodes
+    full_node_api = full_nodes[0]
+    full_node_server = full_node_api.server
+    wallet_node, server_2 = wallets[0]
+    wallet_node_2, server_3 = wallets[1]
+    wallet = wallet_node.wallet_state_manager.main_wallet
+    wallet2 = wallet_node_2.wallet_state_manager.main_wallet
+    ph = await wallet.get_new_puzzlehash()
+    if trusted:
+        wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+        wallet_node_2.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+    else:
+        wallet_node.config["trusted_peers"] = {}
+        wallet_node_2.config["trusted_peers"] = {}
+    await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    await server_3.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    for _ in range(num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32(32 * b"0")))
+    funds = sum(
+        [calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks + 1)]
+    )
+    await time_out_assert(20, wallet.get_confirmed_balance, funds)
-        cat_2_hash = await cat_wallet_2.get_new_inner_hash()
-        tx_records = await cat_wallet.generate_signed_transaction(
-            [uint64(60)], [cat_2_hash], DEFAULT_TX_CONFIG.override(reuse_puzhash=True), fee=uint64(1)
+    async with wallet_node.wallet_state_manager.lock:
-        cat_wallet, _ = await CATWallet.create_new_cat_wallet(
-            wallet_node.wallet_state_manager,
-            wallet,
-            {"identifier": "genesis_by_id"},
-            uint64(100),
-            DEFAULT_TX_CONFIG,
+        cat_wallet, tx_records = await CATWallet.create_new_cat_wallet(
+            wallet_node.wallet_state_manager, wallet, {"identifier": "genesis_by_id"}, uint64(100), DEFAULT_TX_CONFIG
         )
-    tx_queue = await wallet_node.wallet_state_manager.tx_store.get_not_sent()
-    tx_record = tx_queue[0]
-    await full_node_api.process_transaction_records(records=[tx_record])
-        await wallet.wallet_state_manager.add_pending_transactions(tx_records)
-        for tx_record in tx_records:
-            if tx_record.wallet_id is cat_wallet.id():
-                assert tx_record.to_puzzle_hash == cat_2_hash
-                assert len(tx_record.spend_bundle.coin_spends) == 2
-                for cs in tx_record.spend_bundle.coin_spends:
-                    if cs.coin.amount == 100:
-                        old_puzhash = cs.coin.puzzle_hash.hex()
-                new_puzhash = [c.puzzle_hash.hex() for c in tx_record.additions]
-                assert old_puzhash in new_puzhash
+    await full_node_api.process_transaction_records(records=tx_records)
-        await time_out_assert(15, full_node_api.txs_in_mempool, True, tx_records)
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 100)
+    await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 100)
-        await time_out_assert(20, cat_wallet.get_pending_change_balance, 40)
+    assert cat_wallet.cat_info.limitations_program_hash is not None
+    asset_id = cat_wallet.get_asset_id()
-        for i in range(1, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(32 * b"\0"))
+    cat_wallet_2 = await CATWallet.get_or_create_wallet_for_cat(wallet_node_2.wallet_state_manager, wallet2, asset_id)
-        await time_out_assert(30, wallet.get_confirmed_balance, funds - 101)
+    assert cat_wallet.cat_info.limitations_program_hash == cat_wallet_2.cat_info.limitations_program_hash
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 40)
-        await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 40)
+    cat_2_hash = await cat_wallet_2.get_new_inner_hash()
+    tx_records = await cat_wallet.generate_signed_transaction(
+        [uint64(60)], [cat_2_hash], DEFAULT_TX_CONFIG.override(reuse_puzhash=True), fee=uint64(1)
+    )
+    tx_records = await wallet.wallet_state_manager.add_pending_transactions(tx_records)
+    for tx_record in tx_records:
+        if tx_record.wallet_id is cat_wallet.id():
+            assert tx_record.to_puzzle_hash == cat_2_hash
+            assert tx_record.spend_bundle is not None
+            assert len(tx_record.spend_bundle.coin_spends) == 2
+            for cs in tx_record.spend_bundle.coin_spends:
+                if cs.coin.amount == 100:
+                    old_puzhash = cs.coin.puzzle_hash.hex()
+            new_puzhash = [c.puzzle_hash.hex() for c in tx_record.additions]
+            assert old_puzhash in new_puzhash
-        await time_out_assert(30, cat_wallet_2.get_confirmed_balance, 60)
-        await time_out_assert(30, cat_wallet_2.get_unconfirmed_balance, 60)
+    await time_out_assert(15, full_node_api.txs_in_mempool, True, tx_records)
-        cat_hash = await cat_wallet.get_new_inner_hash()
-        tx_records = await cat_wallet_2.generate_signed_transaction([uint64(15)], [cat_hash], DEFAULT_TX_CONFIG)
-        await wallet.wallet_state_manager.add_pending_transactions(tx_records)
+    await time_out_assert(20, cat_wallet.get_pending_change_balance, 40)
-        await time_out_assert(15, full_node_api.txs_in_mempool, True, tx_records)
+    for _ in range(1, num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32(32 * b"\0")))
-        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+    await time_out_assert(30, wallet.get_confirmed_balance, funds - 101)
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 55)
-        await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 55)
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 40)
+    await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 40)
-        height = full_node_api.full_node.blockchain.get_peak_height()
-        await full_node_api.reorg_from_index_to_new_index(ReorgProtocol(height - 1, height + 1, 32 * b"1", None))
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 40)
+    await time_out_assert(30, cat_wallet_2.get_confirmed_balance, 60)
+    await time_out_assert(30, cat_wallet_2.get_unconfirmed_balance, 60)
-    @pytest.mark.parametrize(
-        "trusted",
-        [True, False],
+    cat_hash = await cat_wallet.get_new_inner_hash()
+    tx_records = await cat_wallet_2.generate_signed_transaction([uint64(15)], [cat_hash], DEFAULT_TX_CONFIG)
+    tx_records = await wallet2.wallet_state_manager.add_pending_transactions(tx_records)
+    await time_out_assert(15, full_node_api.txs_in_mempool, True, tx_records)
+    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 55)
+    await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 55)
+    height = full_node_api.full_node.blockchain.get_peak_height()
+    assert height is not None
+    await full_node_api.reorg_from_index_to_new_index(
+        ReorgProtocol(uint32(height - 1), uint32(height + 1), bytes32(32 * b"1"), None)
     )
-    @pytest.mark.anyio
-    async def test_get_wallet_for_asset_id(self, self_hostname, two_wallet_nodes, trusted):
-        num_blocks = 3
-        full_nodes, wallets, _ = two_wallet_nodes
-        full_node_api = full_nodes[0]
-        full_node_server = full_node_api.server
-        wallet_node, server_2 = wallets[0]
-        wallet = wallet_node.wallet_state_manager.main_wallet
-        ph = await wallet.get_new_puzzlehash()
-        if trusted:
-            wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-        else:
-            wallet_node.config["trusted_peers"] = {}
-        await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        for i in range(0, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
-        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(32 * b"0"))
-        funds = sum(
-            [
-                calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
-                for i in range(1, num_blocks + 1)
-            ]
-        )
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 40)
+@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.anyio
+async def test_get_wallet_for_asset_id(
+    self_hostname: str, two_wallet_nodes: OldSimulatorsAndWallets, trusted: bool
+) -> None:
+    num_blocks = 3
+    full_nodes, wallets, _ = two_wallet_nodes
+    full_node_api = full_nodes[0]
+    full_node_server = full_node_api.server
+    wallet_node, server_2 = wallets[0]
+    wallet = wallet_node.wallet_state_manager.main_wallet
+    ph = await wallet.get_new_puzzlehash()
+    if trusted:
+        wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+    else:
+        wallet_node.config["trusted_peers"] = {}
+    await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    for _ in range(num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32(32 * b"0")))
-        await time_out_assert(20, wallet.get_confirmed_balance, funds)
-        async with wallet_node.wallet_state_manager.lock:
-            cat_wallet, _ = await CATWallet.create_new_cat_wallet(
-                wallet_node.wallet_state_manager,
-                wallet,
-                {"identifier": "genesis_by_id"},
-                uint64(100),
-                DEFAULT_TX_CONFIG,
-            )
-        for i in range(1, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(32 * b"0"))
-        asset_id = cat_wallet.get_asset_id()
-        await cat_wallet.set_tail_program(bytes(cat_wallet.cat_info.my_tail).hex())
-        assert await wallet_node.wallet_state_manager.get_wallet_for_asset_id(asset_id) == cat_wallet
-        # Test that the a default CAT will initialize correctly
-        asset = DEFAULT_CATS[next(iter(DEFAULT_CATS))]
-        asset_id = asset["asset_id"]
-        cat_wallet_2 = await CATWallet.get_or_create_wallet_for_cat(wallet_node.wallet_state_manager, wallet, asset_id)
-        assert cat_wallet_2.get_name() == asset["name"]
-        await cat_wallet_2.set_name("Test Name")
-        assert cat_wallet_2.get_name() == "Test Name"
-    @pytest.mark.parametrize(
-        "trusted",
-        [True, False],
+    funds = sum(
+        [calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks + 1)]
     )
-    @pytest.mark.anyio
-    async def test_cat_doesnt_see_eve(self, self_hostname, two_wallet_nodes, trusted):
-        num_blocks = 3
-        full_nodes, wallets, _ = two_wallet_nodes
-        full_node_api = full_nodes[0]
-        full_node_server = full_node_api.server
-        wallet_node, server_2 = wallets[0]
-        wallet_node_2, server_3 = wallets[1]
-        wallet = wallet_node.wallet_state_manager.main_wallet
-        wallet2 = wallet_node_2.wallet_state_manager.main_wallet
-        ph = await wallet.get_new_puzzlehash()
-        if trusted:
-            wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-            wallet_node_2.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-        else:
-            wallet_node.config["trusted_peers"] = {}
-            wallet_node_2.config["trusted_peers"] = {}
-        await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        await server_3.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        for i in range(0, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
-        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(32 * b"0"))
-        funds = sum(
-            [
-                calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
-                for i in range(1, num_blocks + 1)
-            ]
+    await time_out_assert(20, wallet.get_confirmed_balance, funds)
+    async with wallet_node.wallet_state_manager.lock:
+        cat_wallet, _ = await CATWallet.create_new_cat_wallet(
-            wallet_node.wallet_state_manager,
-            wallet,
-            {"identifier": "genesis_by_id"},
-            uint64(100),
-            DEFAULT_TX_CONFIG,
+            wallet_node.wallet_state_manager, wallet, {"identifier": "genesis_by_id"}, uint64(100), DEFAULT_TX_CONFIG
         )
-        await time_out_assert(20, wallet.get_confirmed_balance, funds)
+    for _ in range(1, num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32(32 * b"0")))
-        async with wallet_node.wallet_state_manager.lock:
-            cat_wallet, _ = await CATWallet.create_new_cat_wallet(
-                wallet_node.wallet_state_manager,
-                wallet,
-                {"identifier": "genesis_by_id"},
-                uint64(100),
-                DEFAULT_TX_CONFIG,
-            )
-        tx_records: List[TransactionRecord] = await wallet_node.wallet_state_manager.tx_store.get_not_sent()
-        await full_node_api.process_transaction_records(records=tx_records)
+    asset_id = cat_wallet.get_asset_id()
+    assert cat_wallet.cat_info.my_tail is not None
+    await cat_wallet.set_tail_program(bytes(cat_wallet.cat_info.my_tail).hex())
+    assert await wallet_node.wallet_state_manager.get_wallet_for_asset_id(asset_id) == cat_wallet
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 100)
-        await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 100)
+    # Test that the a default CAT will initialize correctly
+    asset = DEFAULT_CATS[next(iter(DEFAULT_CATS))]
+    asset_id = asset["asset_id"]
+    cat_wallet_2 = await CATWallet.get_or_create_wallet_for_cat(wallet_node.wallet_state_manager, wallet, asset_id)
+    assert cat_wallet_2.get_name() == asset["name"]
+    await cat_wallet_2.set_name("Test Name")
+    assert cat_wallet_2.get_name() == "Test Name"
-        assert cat_wallet.cat_info.limitations_program_hash is not None
-        asset_id = cat_wallet.get_asset_id()
-        cat_wallet_2: CATWallet = await CATWallet.get_or_create_wallet_for_cat(
-            wallet_node_2.wallet_state_manager, wallet2, asset_id
-        )
+@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.anyio
+async def test_cat_doesnt_see_eve(self_hostname: str, two_wallet_nodes: OldSimulatorsAndWallets, trusted: bool) -> None:
+    num_blocks = 3
+    full_nodes, wallets, _ = two_wallet_nodes
+    full_node_api = full_nodes[0]
+    full_node_server = full_node_api.server
+    wallet_node, server_2 = wallets[0]
+    wallet_node_2, server_3 = wallets[1]
+    wallet = wallet_node.wallet_state_manager.main_wallet
+    wallet2 = wallet_node_2.wallet_state_manager.main_wallet
+    ph = await wallet.get_new_puzzlehash()
+    if trusted:
+        wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+        wallet_node_2.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+    else:
+        wallet_node.config["trusted_peers"] = {}
+        wallet_node_2.config["trusted_peers"] = {}
+    await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    await server_3.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    for _ in range(num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32(32 * b"0")))
+    funds = sum(
+        [calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks + 1)]
+    )
-        assert cat_wallet.cat_info.limitations_program_hash == cat_wallet_2.cat_info.limitations_program_hash
+    await time_out_assert(20, wallet.get_confirmed_balance, funds)
-        cat_2_hash = await cat_wallet_2.get_new_inner_hash()
-        tx_records = await cat_wallet.generate_signed_transaction(
-            [uint64(60)], [cat_2_hash], DEFAULT_TX_CONFIG, fee=uint64(1)
+    async with wallet_node.wallet_state_manager.lock:
-        cat_wallet, _ = await CATWallet.create_new_cat_wallet(
-            wallet_node.wallet_state_manager,
-            wallet,
-            {"identifier": "genesis_by_id"},
-            uint64(100),
-            DEFAULT_TX_CONFIG,
+        cat_wallet, tx_records = await CATWallet.create_new_cat_wallet(
+            wallet_node.wallet_state_manager, wallet, {"identifier": "genesis_by_id"}, uint64(100), DEFAULT_TX_CONFIG
         )
-    tx_records = await wallet_node.wallet_state_manager.tx_store.get_not_sent()
-        await wallet.wallet_state_manager.add_pending_transactions(tx_records)
-        await full_node_api.process_transaction_records(records=tx_records)
+    await full_node_api.process_transaction_records(records=tx_records)
-        await time_out_assert(30, wallet.get_confirmed_balance, funds - 101)
-        await time_out_assert(30, wallet.get_unconfirmed_balance, funds - 101)
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 100)
+    await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 100)
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 40)
-        await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 40)
+    assert cat_wallet.cat_info.limitations_program_hash is not None
+    asset_id = cat_wallet.get_asset_id()
-        await time_out_assert(20, cat_wallet_2.get_confirmed_balance, 60)
-        await time_out_assert(20, cat_wallet_2.get_unconfirmed_balance, 60)
+    cat_wallet_2 = await CATWallet.get_or_create_wallet_for_cat(wallet_node_2.wallet_state_manager, wallet2, asset_id)
-        cc2_ph = await cat_wallet_2.get_new_cat_puzzle_hash()
-        [tx_record] = await wallet.wallet_state_manager.main_wallet.generate_signed_transaction(
-            10, cc2_ph, DEFAULT_TX_CONFIG, 0
-        )
-        await wallet.wallet_state_manager.add_pending_transactions([tx_record])
-        await full_node_api.process_transaction_records(records=[tx_record])
+    assert cat_wallet.cat_info.limitations_program_hash == cat_wallet_2.cat_info.limitations_program_hash
-        id = cat_wallet_2.id()
-        wsm = cat_wallet_2.wallet_state_manager
+    cat_2_hash = await cat_wallet_2.get_new_inner_hash()
+    tx_records = await cat_wallet.generate_signed_transaction(
+        [uint64(60)], [cat_2_hash], DEFAULT_TX_CONFIG, fee=uint64(1)
+    )
+    tx_records = await wallet.wallet_state_manager.add_pending_transactions(tx_records)
+    await full_node_api.process_transaction_records(records=tx_records)
+    await time_out_assert(30, wallet.get_confirmed_balance, funds - 101)
+    await time_out_assert(30, wallet.get_unconfirmed_balance, funds - 101)
-        async def query_and_assert_transactions(wsm, id):
-            all_txs = await wsm.tx_store.get_all_transactions_for_wallet(id)
-            return len(list(filter(lambda tx: tx.amount == 10, all_txs)))
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 40)
+    await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 40)
-        await time_out_assert(20, query_and_assert_transactions, 0, wsm, id)
-        await time_out_assert(20, wsm.get_confirmed_balance_for_wallet, 60, id)
-        await time_out_assert(20, cat_wallet_2.get_confirmed_balance, 60)
-        await time_out_assert(20, cat_wallet_2.get_unconfirmed_balance, 60)
+    await time_out_assert(20, cat_wallet_2.get_confirmed_balance, 60)
+    await time_out_assert(20, cat_wallet_2.get_unconfirmed_balance, 60)
-    @pytest.mark.parametrize(
-        "trusted",
-        [True, False],
+    cc2_ph = await cat_wallet_2.get_new_cat_puzzle_hash()
+    [tx_record] = await wallet.wallet_state_manager.main_wallet.generate_signed_transaction(
+        uint64(10), cc2_ph, DEFAULT_TX_CONFIG
     )
-    @pytest.mark.anyio
-    async def test_cat_spend_multiple(self, self_hostname, three_wallet_nodes, trusted):
-        num_blocks = 3
-        full_nodes, wallets, _ = three_wallet_nodes
-        full_node_api = full_nodes[0]
-        full_node_server = full_node_api.server
-        wallet_node_0, wallet_server_0 = wallets[0]
-        wallet_node_1, wallet_server_1 = wallets[1]
-        wallet_node_2, wallet_server_2 = wallets[2]
-        wallet_0 = wallet_node_0.wallet_state_manager.main_wallet
-        wallet_1 = wallet_node_1.wallet_state_manager.main_wallet
-        wallet_2 = wallet_node_2.wallet_state_manager.main_wallet
-        ph = await wallet_0.get_new_puzzlehash()
-        if trusted:
-            wallet_node_0.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-            wallet_node_1.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-            wallet_node_2.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-        else:
-            wallet_node_0.config["trusted_peers"] = {}
-            wallet_node_1.config["trusted_peers"] = {}
-            wallet_node_2.config["trusted_peers"] = {}
-        await wallet_server_0.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        await wallet_server_1.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        await wallet_server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        for i in range(0, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
-        funds = sum(
-            [calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks)]
-        )
+    [tx_record] = await wallet.wallet_state_manager.add_pending_transactions([tx_record])
+    await full_node_api.process_transaction_records(records=[tx_record])
-        await time_out_assert(20, wallet_0.get_confirmed_balance, funds)
+    id = cat_wallet_2.id()
+    wsm = cat_wallet_2.wallet_state_manager
-        async with wallet_node_0.wallet_state_manager.lock:
-            cat_wallet_0, _ = await CATWallet.create_new_cat_wallet(
-                wallet_node_0.wallet_state_manager,
-                wallet_0,
-                {"identifier": "genesis_by_id"},
-                uint64(100),
-                DEFAULT_TX_CONFIG,
-            )
-        tx_records: List[TransactionRecord] = await wallet_node_0.wallet_state_manager.tx_store.get_not_sent()
-        await full_node_api.process_transaction_records(records=tx_records)
+    async def query_and_assert_transactions(wsm: WalletStateManager, id: uint32) -> int:
+        all_txs = await wsm.tx_store.get_all_transactions_for_wallet(id)
+        return len(list(filter(lambda tx: tx.amount == 10, all_txs)))
-        await time_out_assert(20, cat_wallet_0.get_confirmed_balance, 100)
-        await time_out_assert(20, cat_wallet_0.get_unconfirmed_balance, 100)
+    await time_out_assert(20, query_and_assert_transactions, 0, wsm, id)
+    await time_out_assert(20, wsm.get_confirmed_balance_for_wallet, 60, id)
+    await time_out_assert(20, cat_wallet_2.get_confirmed_balance, 60)
+    await time_out_assert(20, cat_wallet_2.get_unconfirmed_balance, 60)
-        assert cat_wallet_0.cat_info.limitations_program_hash is not None
-        asset_id = cat_wallet_0.get_asset_id()
-        cat_wallet_1: CATWallet = await CATWallet.get_or_create_wallet_for_cat(
-            wallet_node_1.wallet_state_manager, wallet_1, asset_id
-        )
+@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.anyio
+async def test_cat_spend_multiple(
+    self_hostname: str, three_wallet_nodes: OldSimulatorsAndWallets, trusted: bool
+) -> None:
+    num_blocks = 3
+    full_nodes, wallets, _ = three_wallet_nodes
+    full_node_api = full_nodes[0]
+    full_node_server = full_node_api.server
+    wallet_node_0, wallet_server_0 = wallets[0]
+    wallet_node_1, wallet_server_1 = wallets[1]
+    wallet_node_2, wallet_server_2 = wallets[2]
+    wallet_0 = wallet_node_0.wallet_state_manager.main_wallet
+    wallet_1 = wallet_node_1.wallet_state_manager.main_wallet
+    wallet_2 = wallet_node_2.wallet_state_manager.main_wallet
+    ph = await wallet_0.get_new_puzzlehash()
+    if trusted:
+        wallet_node_0.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+        wallet_node_1.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+        wallet_node_2.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+    else:
+        wallet_node_0.config["trusted_peers"] = {}
+        wallet_node_1.config["trusted_peers"] = {}
+        wallet_node_2.config["trusted_peers"] = {}
+    await wallet_server_0.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    await wallet_server_1.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    await wallet_server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    for _ in range(num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+    funds = sum(
+        [calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks)]
+    )
-        cat_wallet_2: CATWallet = await CATWallet.get_or_create_wallet_for_cat(
-            wallet_node_2.wallet_state_manager, wallet_2, asset_id
+    await time_out_assert(20, wallet_0.get_confirmed_balance, funds)
+    async with wallet_node_0.wallet_state_manager.lock:
-        cat_wallet_0, _ = await CATWallet.create_new_cat_wallet(
+        cat_wallet_0, tx_records = await CATWallet.create_new_cat_wallet(
+            wallet_node_0.wallet_state_manager,
+            wallet_0,
+            {"identifier": "genesis_by_id"},
+            uint64(100),
+            DEFAULT_TX_CONFIG,
         )
-    tx_records = await wallet_node_0.wallet_state_manager.tx_store.get_not_sent()
+    await full_node_api.process_transaction_records(records=tx_records)
-        assert cat_wallet_0.cat_info.limitations_program_hash == cat_wallet_1.cat_info.limitations_program_hash
-        assert cat_wallet_0.cat_info.limitations_program_hash == cat_wallet_2.cat_info.limitations_program_hash
+    await time_out_assert(20, cat_wallet_0.get_confirmed_balance, 100)
+    await time_out_assert(20, cat_wallet_0.get_unconfirmed_balance, 100)
-        cat_1_hash = await cat_wallet_1.get_new_inner_hash()
-        cat_2_hash = await cat_wallet_2.get_new_inner_hash()
+    assert cat_wallet_0.cat_info.limitations_program_hash is not None
+    asset_id = cat_wallet_0.get_asset_id()
-        tx_records = await cat_wallet_0.generate_signed_transaction(
-            [uint64(60), uint64(20)], [cat_1_hash, cat_2_hash], DEFAULT_TX_CONFIG
-        )
-        await wallet_0.wallet_state_manager.add_pending_transactions(tx_records)
-        await full_node_api.process_transaction_records(records=tx_records)
+    cat_wallet_1 = await CATWallet.get_or_create_wallet_for_cat(wallet_node_1.wallet_state_manager, wallet_1, asset_id)
-        await time_out_assert(20, cat_wallet_0.get_confirmed_balance, 20)
-        await time_out_assert(20, cat_wallet_0.get_unconfirmed_balance, 20)
+    cat_wallet_2 = await CATWallet.get_or_create_wallet_for_cat(wallet_node_2.wallet_state_manager, wallet_2, asset_id)
-        await time_out_assert(30, cat_wallet_1.get_confirmed_balance, 60)
-        await time_out_assert(30, cat_wallet_1.get_unconfirmed_balance, 60)
+    assert cat_wallet_0.cat_info.limitations_program_hash == cat_wallet_1.cat_info.limitations_program_hash
+    assert cat_wallet_0.cat_info.limitations_program_hash == cat_wallet_2.cat_info.limitations_program_hash
-        await time_out_assert(30, cat_wallet_2.get_confirmed_balance, 20)
-        await time_out_assert(30, cat_wallet_2.get_unconfirmed_balance, 20)
+    cat_1_hash = await cat_wallet_1.get_new_inner_hash()
+    cat_2_hash = await cat_wallet_2.get_new_inner_hash()
-        cat_hash = await cat_wallet_0.get_new_inner_hash()
+    tx_records = await cat_wallet_0.generate_signed_transaction(
+        [uint64(60), uint64(20)], [cat_1_hash, cat_2_hash], DEFAULT_TX_CONFIG
+    )
+    tx_records = await wallet_0.wallet_state_manager.add_pending_transactions(tx_records)
+    await full_node_api.process_transaction_records(records=tx_records)
+    await time_out_assert(20, cat_wallet_0.get_confirmed_balance, 20)
+    await time_out_assert(20, cat_wallet_0.get_unconfirmed_balance, 20)
+    await time_out_assert(30, cat_wallet_1.get_confirmed_balance, 60)
+    await time_out_assert(30, cat_wallet_1.get_unconfirmed_balance, 60)
+    await time_out_assert(30, cat_wallet_2.get_confirmed_balance, 20)
+    await time_out_assert(30, cat_wallet_2.get_unconfirmed_balance, 20)
-        tx_records = await cat_wallet_1.generate_signed_transaction([uint64(15)], [cat_hash], DEFAULT_TX_CONFIG)
-        await wallet_1.wallet_state_manager.add_pending_transactions(tx_records)
+    cat_hash = await cat_wallet_0.get_new_inner_hash()
-        tx_records_2 = await cat_wallet_2.generate_signed_transaction([uint64(20)], [cat_hash], DEFAULT_TX_CONFIG)
-        await wallet_2.wallet_state_manager.add_pending_transactions(tx_records_2)
+    tx_records = await cat_wallet_1.generate_signed_transaction([uint64(15)], [cat_hash], DEFAULT_TX_CONFIG)
+    tx_records = await wallet_1.wallet_state_manager.add_pending_transactions(tx_records)
-        await full_node_api.process_transaction_records(records=[*tx_records, *tx_records_2])
+    tx_records_2 = await cat_wallet_2.generate_signed_transaction([uint64(20)], [cat_hash], DEFAULT_TX_CONFIG)
+    tx_records_2 = await wallet_2.wallet_state_manager.add_pending_transactions(tx_records_2)
-        await time_out_assert(20, cat_wallet_0.get_confirmed_balance, 55)
-        await time_out_assert(20, cat_wallet_0.get_unconfirmed_balance, 55)
+    await full_node_api.process_transaction_records(records=[*tx_records, *tx_records_2])
-        await time_out_assert(30, cat_wallet_1.get_confirmed_balance, 45)
-        await time_out_assert(30, cat_wallet_1.get_unconfirmed_balance, 45)
+    await time_out_assert(20, cat_wallet_0.get_confirmed_balance, 55)
+    await time_out_assert(20, cat_wallet_0.get_unconfirmed_balance, 55)
-        await time_out_assert(30, cat_wallet_2.get_confirmed_balance, 0)
-        await time_out_assert(30, cat_wallet_2.get_unconfirmed_balance, 0)
+    await time_out_assert(30, cat_wallet_1.get_confirmed_balance, 45)
+    await time_out_assert(30, cat_wallet_1.get_unconfirmed_balance, 45)
-        txs = await wallet_1.wallet_state_manager.tx_store.get_transactions_between(cat_wallet_1.id(), 0, 100000)
-        print(len(txs))
-        # Test with Memo
-        tx_records_3: TransactionRecord = await cat_wallet_1.generate_signed_transaction(
-            [uint64(30)], [cat_hash], DEFAULT_TX_CONFIG, memos=[[b"Markus Walburg"]]
+    await time_out_assert(30, cat_wallet_2.get_confirmed_balance, 0)
+    await time_out_assert(30, cat_wallet_2.get_unconfirmed_balance, 0)
+    txs = await wallet_1.wallet_state_manager.tx_store.get_transactions_between(cat_wallet_1.id(), 0, 100000)
+    # Test with Memo
+    tx_records_3 = await cat_wallet_1.generate_signed_transaction(
+        [uint64(30)], [cat_hash], DEFAULT_TX_CONFIG, memos=[[b"Markus Walburg"]]
+    )
+    with pytest.raises(ValueError):
+        await cat_wallet_1.generate_signed_transaction(
+            [uint64(30)], [cat_hash], DEFAULT_TX_CONFIG, memos=[[b"too"], [b"many"], [b"memos"]]
         )
-        with pytest.raises(ValueError):
-            await cat_wallet_1.generate_signed_transaction(
-                [uint64(30)], [cat_hash], DEFAULT_TX_CONFIG, memos=[[b"too"], [b"many"], [b"memos"]]
-            )
-        await wallet_1.wallet_state_manager.add_pending_transactions(tx_records_3)
-        await time_out_assert(15, full_node_api.txs_in_mempool, True, tx_records_3)
-        txs = await wallet_1.wallet_state_manager.tx_store.get_transactions_between(cat_wallet_1.id(), 0, 100000)
-        for tx in txs:
-            if tx.amount == 30:
-                memos = tx.get_memos()
-                assert len(memos) == 2  # One for tx, one for change
-                assert b"Markus Walburg" in [v for v_list in memos.values() for v in v_list]
-                assert list(memos.keys())[0] in [a.name() for a in tx.spend_bundle.additions()]
-    @pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN, ConsensusMode.HARD_FORK_2_0], reason="save time")
-    @pytest.mark.parametrize("trusted", [True, False])
-    @pytest.mark.anyio
-    async def test_cat_max_amount_send(self, self_hostname, two_wallet_nodes, trusted):
-        num_blocks = 3
-        full_nodes, wallets, _ = two_wallet_nodes
-        full_node_api = full_nodes[0]
-        full_node_server = full_node_api.server
-        wallet_node, server_2 = wallets[0]
-        wallet_node_2, server_3 = wallets[1]
-        wallet = wallet_node.wallet_state_manager.main_wallet
-        ph = await wallet.get_new_puzzlehash()
-        if trusted:
-            wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-            wallet_node_2.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-        else:
-            wallet_node.config["trusted_peers"] = {}
-            wallet_node_2.config["trusted_peers"] = {}
-        await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        await server_3.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        for i in range(0, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
-        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(32 * b"0"))
-        funds = sum(
-            [
-                calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
-                for i in range(1, num_blocks + 1)
-            ]
+    tx_records_3 = await wallet_1.wallet_state_manager.add_pending_transactions(tx_records_3)
+    await time_out_assert(15, full_node_api.txs_in_mempool, True, tx_records_3)
+    txs = await wallet_1.wallet_state_manager.tx_store.get_transactions_between(cat_wallet_1.id(), 0, 100000)
+    for tx in txs:
+        if tx.amount == 30:
+            memos = tx.get_memos()
+            assert len(memos) == 2  # One for tx, one for change
+            assert b"Markus Walburg" in [v for v_list in memos.values() for v in v_list]
+            assert tx.spend_bundle is not None
+            assert list(memos.keys())[0] in [a.name() for a in tx.spend_bundle.additions()]
+@pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN, ConsensusMode.HARD_FORK_2_0], reason="save time")
+@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.anyio
+async def test_cat_max_amount_send(
+    self_hostname: str, two_wallet_nodes: OldSimulatorsAndWallets, trusted: bool
+) -> None:
+    num_blocks = 3
+    full_nodes, wallets, _ = two_wallet_nodes
+    full_node_api = full_nodes[0]
+    full_node_server = full_node_api.server
+    wallet_node, server_2 = wallets[0]
+    wallet_node_2, server_3 = wallets[1]
+    wallet = wallet_node.wallet_state_manager.main_wallet
+    ph = await wallet.get_new_puzzlehash()
+    if trusted:
+        wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+        wallet_node_2.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+    else:
+        wallet_node.config["trusted_peers"] = {}
+        wallet_node_2.config["trusted_peers"] = {}
+    await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    await server_3.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    for _ in range(num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32(32 * b"0")))
+    funds = sum(
+        [calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks + 1)]
+    )
+    await time_out_assert(20, wallet.get_confirmed_balance, funds)
+    async with wallet_node.wallet_state_manager.lock:
-        cat_wallet, _ = await CATWallet.create_new_cat_wallet(
-            wallet_node.wallet_state_manager,
-            wallet,
-            {"identifier": "genesis_by_id"},
-            uint64(100000),
-            DEFAULT_TX_CONFIG,
+        cat_wallet, tx_records = await CATWallet.create_new_cat_wallet(
+            wallet_node.wallet_state_manager, wallet, {"identifier": "genesis_by_id"}, uint64(100000), DEFAULT_TX_CONFIG
         )
-    tx_records = await wallet_node.wallet_state_manager.tx_store.get_not_sent()
+    await full_node_api.process_transaction_records(records=tx_records)
-        await time_out_assert(20, wallet.get_confirmed_balance, funds)
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 100000)
+    await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 100000)
-        async with wallet_node.wallet_state_manager.lock:
-            cat_wallet, _ = await CATWallet.create_new_cat_wallet(
-                wallet_node.wallet_state_manager,
-                wallet,
-                {"identifier": "genesis_by_id"},
-                uint64(100000),
-                DEFAULT_TX_CONFIG,
-            )
-        tx_records: List[TransactionRecord] = await wallet_node.wallet_state_manager.tx_store.get_not_sent()
-        await full_node_api.process_transaction_records(records=tx_records)
+    assert cat_wallet.cat_info.limitations_program_hash is not None
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 100000)
-        await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 100000)
+    cat_2 = await cat_wallet.get_new_inner_puzzle()
+    cat_2_hash = cat_2.get_tree_hash()
+    amounts = []
+    puzzle_hashes = []
+    for i in range(1, 50):
+        amounts.append(uint64(i))
+        puzzle_hashes.append(cat_2_hash)
+    spent_coint = (await cat_wallet.get_cat_spendable_coins())[0].coin
+    tx_records = await cat_wallet.generate_signed_transaction(
+        amounts, puzzle_hashes, DEFAULT_TX_CONFIG, coins={spent_coint}
+    )
+    tx_records = await wallet.wallet_state_manager.add_pending_transactions(tx_records)
+    await full_node_api.process_transaction_records(records=tx_records)
-        assert cat_wallet.cat_info.limitations_program_hash is not None
+    await asyncio.sleep(2)
-        cat_2 = await cat_wallet.get_new_inner_puzzle()
-        cat_2_hash = cat_2.get_tree_hash()
-        amounts = []
-        puzzle_hashes = []
+    async def check_all_there() -> bool:
+        spendable = await cat_wallet.get_cat_spendable_coins()
+        spendable_name_set = set()
+        for record in spendable:
+            spendable_name_set.add(record.coin.name())
+        puzzle_hash = construct_cat_puzzle(CAT_MOD, cat_wallet.cat_info.limitations_program_hash, cat_2).get_tree_hash()
         for i in range(1, 50):
-            coin = Coin(spent_coint.name(), puzzle_hash, i)
-            amounts.append(uint64(i))
-            puzzle_hashes.append(cat_2_hash)
-        spent_coint = (await cat_wallet.get_cat_spendable_coins())[0].coin
-        tx_records = await cat_wallet.generate_signed_transaction(
-            amounts, puzzle_hashes, DEFAULT_TX_CONFIG, coins={spent_coint}
-        )
-        await wallet.wallet_state_manager.add_pending_transactions(tx_records)
-        await full_node_api.process_transaction_records(records=tx_records)
-        await asyncio.sleep(2)
-        async def check_all_there():
-            spendable = await cat_wallet.get_cat_spendable_coins()
-            spendable_name_set = set()
-            for record in spendable:
-                spendable_name_set.add(record.coin.name())
-            puzzle_hash = construct_cat_puzzle(
-                CAT_MOD, cat_wallet.cat_info.limitations_program_hash, cat_2
-            ).get_tree_hash()
-            for i in range(1, 50):
-                coin = Coin(spent_coint.name(), puzzle_hash, i)
-                if coin.name() not in spendable_name_set:
-                    return False
-            return True
-        await time_out_assert(20, check_all_there, True)
-        await asyncio.sleep(5)
-        max_sent_amount = await cat_wallet.get_max_send_amount()
-        # 1) Generate transaction that is under the limit
-        [transaction_record] = await cat_wallet.generate_signed_transaction(
-            [max_sent_amount - 1],
-            [ph],
-            DEFAULT_TX_CONFIG,
-        )
+            coin = Coin(spent_coint.name(), puzzle_hash, uint64(i))
+            if coin.name() not in spendable_name_set:
+                return False
+        return True
+    await time_out_assert(20, check_all_there, True)
+    await asyncio.sleep(5)
+    max_sent_amount = await cat_wallet.get_max_send_amount()
+    # 1) Generate transaction that is under the limit
+    [transaction_record] = await cat_wallet.generate_signed_transaction(
+        [uint64(max_sent_amount - 1)], [ph], DEFAULT_TX_CONFIG
+    )
+    assert transaction_record.amount == uint64(max_sent_amount - 1)
-        assert transaction_record.amount == uint64(max_sent_amount - 1)
+    # 2) Generate transaction that is equal to limit
+    [transaction_record] = await cat_wallet.generate_signed_transaction(
+        [uint64(max_sent_amount)], [ph], DEFAULT_TX_CONFIG
+    )
+    assert transaction_record.amount == uint64(max_sent_amount)
-        # 2) Generate transaction that is equal to limit
-        [transaction_record] = await cat_wallet.generate_signed_transaction(
-            [max_sent_amount],
-            [ph],
-            DEFAULT_TX_CONFIG,
-        )
+    # 3) Generate transaction that is greater than limit
+    with pytest.raises(ValueError):
+        await cat_wallet.generate_signed_transaction([uint64(max_sent_amount + 1)], [ph], DEFAULT_TX_CONFIG)
-        assert transaction_record.amount == uint64(max_sent_amount)
-        # 3) Generate transaction that is greater than limit
-        with pytest.raises(ValueError):
-            await cat_wallet.generate_signed_transaction(
-                [max_sent_amount + 1],
-                [ph],
-                DEFAULT_TX_CONFIG,
-            )
-    @pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN, ConsensusMode.HARD_FORK_2_0], reason="save time")
-    @pytest.mark.parametrize("trusted", [True, False])
-    @pytest.mark.parametrize("autodiscovery", [True, False])
-    @pytest.mark.anyio
-    async def test_cat_hint(self, self_hostname, two_wallet_nodes, trusted, autodiscovery):
-        num_blocks = 3
-        full_nodes, wallets, _ = two_wallet_nodes
-        full_node_api = full_nodes[0]
-        full_node_server = full_node_api.server
-        wallet_node, server_2 = wallets[0]
-        wallet_node_2, server_3 = wallets[1]
-        wallet = wallet_node.wallet_state_manager.main_wallet
-        wallet2 = wallet_node_2.wallet_state_manager.main_wallet
-        ph = await wallet.get_new_puzzlehash()
-        if trusted:
-            wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-            wallet_node_2.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-        else:
-            wallet_node.config["trusted_peers"] = {}
-            wallet_node_2.config["trusted_peers"] = {}
-        wallet_node.config["automatically_add_unknown_cats"] = autodiscovery
-        wallet_node_2.config["automatically_add_unknown_cats"] = autodiscovery
-        await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        await server_3.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        for i in range(0, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
-        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(32 * b"0"))
-        funds = sum(
-            [
-                calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
-                for i in range(1, num_blocks + 1)
-            ]
-        )
-        await time_out_assert(20, wallet.get_confirmed_balance, funds)
-        async with wallet_node.wallet_state_manager.lock:
-            cat_wallet, _ = await CATWallet.create_new_cat_wallet(
-                wallet_node.wallet_state_manager,
-                wallet,
-                {"identifier": "genesis_by_id"},
-                uint64(100),
-                DEFAULT_TX_CONFIG,
-            )
-        tx_records: List[TransactionRecord] = await wallet_node.wallet_state_manager.tx_store.get_not_sent()
-        await full_node_api.process_transaction_records(records=tx_records)
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 100)
-        await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 100)
-        assert cat_wallet.cat_info.limitations_program_hash is not None
-        cat_2_hash = await wallet2.get_new_puzzlehash()
-        tx_records = await cat_wallet.generate_signed_transaction(
-            [uint64(60)], [cat_2_hash], DEFAULT_TX_CONFIG, memos=[[cat_2_hash]]
+@pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN, ConsensusMode.HARD_FORK_2_0], reason="save time")
+@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.parametrize("autodiscovery", [True, False])
+@pytest.mark.anyio
+async def test_cat_hint(
+    self_hostname: str, two_wallet_nodes: OldSimulatorsAndWallets, trusted: bool, autodiscovery: bool
+) -> None:
+    num_blocks = 3
+    full_nodes, wallets, _ = two_wallet_nodes
+    full_node_api = full_nodes[0]
+    full_node_server = full_node_api.server
+    wallet_node, server_2 = wallets[0]
+    wallet_node_2, server_3 = wallets[1]
+    wallet = wallet_node.wallet_state_manager.main_wallet
+    wallet2 = wallet_node_2.wallet_state_manager.main_wallet
+    ph = await wallet.get_new_puzzlehash()
+    if trusted:
+        wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+        wallet_node_2.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+    else:
+        wallet_node.config["trusted_peers"] = {}
+        wallet_node_2.config["trusted_peers"] = {}
+    wallet_node.config["automatically_add_unknown_cats"] = autodiscovery
+    wallet_node_2.config["automatically_add_unknown_cats"] = autodiscovery
+    await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    await server_3.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    for _ in range(num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32(32 * b"0")))
+    funds = sum(
+        [calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks + 1)]
+    )
+    await time_out_assert(20, wallet.get_confirmed_balance, funds)
+    async with wallet_node.wallet_state_manager.lock:
-        cat_wallet, _ = await CATWallet.create_new_cat_wallet(
-            wallet_node.wallet_state_manager,
-            wallet,
-            {"identifier": "genesis_by_id"},
-            uint64(100),
-            DEFAULT_TX_CONFIG,
+        cat_wallet, tx_records = await CATWallet.create_new_cat_wallet(
+            wallet_node.wallet_state_manager, wallet, {"identifier": "genesis_by_id"}, uint64(100), DEFAULT_TX_CONFIG
         )
-    tx_records = await wallet_node.wallet_state_manager.tx_store.get_not_sent()
+    await full_node_api.process_transaction_records(records=tx_records)
-        await wallet.wallet_state_manager.add_pending_transactions(tx_records)
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 100)
+    await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 100)
+    assert cat_wallet.cat_info.limitations_program_hash is not None
-        await full_node_api.process_transaction_records(records=tx_records)
+    cat_2_hash = await wallet2.get_new_puzzlehash()
+    tx_records = await cat_wallet.generate_signed_transaction(
+        [uint64(60)], [cat_2_hash], DEFAULT_TX_CONFIG, memos=[[cat_2_hash]]
+    )
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 40)
-        await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 40)
+    tx_records = await wallet.wallet_state_manager.add_pending_transactions(tx_records)
-        async def check_wallets(node):
-            return len(node.wallet_state_manager.wallets.keys())
+    await full_node_api.process_transaction_records(records=tx_records)
-        if autodiscovery:
-            # Autodiscovery enabled: test that wallet was created at this point
-            await time_out_assert(20, check_wallets, 2, wallet_node_2)
-        else:
-            # Autodiscovery disabled: test that no wallet was created
-            await time_out_assert(20, check_wallets, 1, wallet_node_2)
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 40)
+    await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 40)
-        # Then we update the wallet's default CATs
-        wallet_node_2.wallet_state_manager.default_cats = {
-            cat_wallet.cat_info.limitations_program_hash.hex(): {
-                "asset_id": cat_wallet.cat_info.limitations_program_hash.hex(),
-                "name": "Test",
-                "symbol": "TST",
-            }
+    if autodiscovery:
+        # Autodiscovery enabled: test that wallet was created at this point
+        await time_out_assert(20, check_wallets, 2, wallet_node_2)
+    else:
+        # Autodiscovery disabled: test that no wallet was created
+        await time_out_assert(20, check_wallets, 1, wallet_node_2)
+    # Then we update the wallet's default CATs
+    wallet_node_2.wallet_state_manager.default_cats = {
+        cat_wallet.cat_info.limitations_program_hash.hex(): {
+            "asset_id": cat_wallet.cat_info.limitations_program_hash.hex(),
+            "name": "Test",
+            "symbol": "TST",
         }
+    }
-        # Then we send another transaction
-        tx_records = await cat_wallet.generate_signed_transaction(
-            [uint64(10)], [cat_2_hash], DEFAULT_TX_CONFIG, memos=[[cat_2_hash]]
-        )
+    # Then we send another transaction
+    tx_records = await cat_wallet.generate_signed_transaction(
+        [uint64(10)], [cat_2_hash], DEFAULT_TX_CONFIG, memos=[[cat_2_hash]]
+    )
-        await wallet.wallet_state_manager.add_pending_transactions(tx_records)
+    tx_records = await wallet.wallet_state_manager.add_pending_transactions(tx_records)
-        await full_node_api.process_transaction_records(records=tx_records)
+    await full_node_api.process_transaction_records(records=tx_records)
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 30)
-        await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 30)
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 30)
+    await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 30)
-        # Now we check that another wallet WAS created, even if autodiscovery was disabled
-        await time_out_assert(20, check_wallets, 2, wallet_node_2)
-        cat_wallet_2 = wallet_node_2.wallet_state_manager.wallets[2]
+    # Now we check that another wallet WAS created, even if autodiscovery was disabled
+    await time_out_assert(20, check_wallets, 2, wallet_node_2)
+    cat_wallet_2 = wallet_node_2.wallet_state_manager.wallets[uint32(2)]
+    assert isinstance(cat_wallet_2, CATWallet)
+    # Previous balance + balance that triggered creation in case of disabled autodiscovery
+    await time_out_assert(30, cat_wallet_2.get_confirmed_balance, 70)
+    await time_out_assert(30, cat_wallet_2.get_unconfirmed_balance, 70)
+    cat_hash = await cat_wallet.get_new_inner_hash()
+    tx_records = await cat_wallet_2.generate_signed_transaction([uint64(5)], [cat_hash], DEFAULT_TX_CONFIG)
+    tx_records = await wallet2.wallet_state_manager.add_pending_transactions(tx_records)
-        # Previous balance + balance that triggered creation in case of disabled autodiscovery
-        await time_out_assert(30, cat_wallet_2.get_confirmed_balance, 70)
-        await time_out_assert(30, cat_wallet_2.get_unconfirmed_balance, 70)
+    await full_node_api.process_transaction_records(records=tx_records)
-        cat_hash = await cat_wallet.get_new_inner_hash()
-        tx_records = await cat_wallet_2.generate_signed_transaction([uint64(5)], [cat_hash], DEFAULT_TX_CONFIG)
-        await wallet.wallet_state_manager.add_pending_transactions(tx_records)
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, 35)
+    await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 35)
-        await full_node_api.process_transaction_records(records=tx_records)
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, 35)
-        await time_out_assert(20, cat_wallet.get_unconfirmed_balance, 35)
+@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.anyio
+async def test_cat_change_detection(
+    self_hostname: str, one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices, trusted: bool
+) -> None:
+    num_blocks = 1
+    full_nodes, wallets, bt = one_wallet_and_one_simulator_services
+    full_node_api = full_nodes[0]._api
+    full_node_server = full_node_api.full_node.server
+    wallet_service_0 = wallets[0]
+    wallet_node_0 = wallet_service_0._node
+    wallet_0 = wallet_node_0.wallet_state_manager.main_wallet
+    assert wallet_service_0.rpc_server is not None
+    client_0 = await WalletRpcClient.create(
+        bt.config["self_hostname"],
+        wallet_service_0.rpc_server.listen_port,
+        wallet_service_0.root_path,
+        wallet_service_0.config,
+    )
+    wallet_node_0.config["automatically_add_unknown_cats"] = True
-    @pytest.mark.parametrize(
-        "trusted",
-        [True, False],
+    if trusted:
+        wallet_node_0.config["trusted_peers"] = {
+            full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()
+        }
+    else:
+        wallet_node_0.config["trusted_peers"] = {}
+    await wallet_node_0.server.start_client(PeerInfo(self_hostname, uint16(full_node_server.get_port())), None)
+    await full_node_api.farm_blocks_to_wallet(count=num_blocks, wallet=wallet_0)
+    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node_0, timeout=20)
+    # Mint CAT to ourselves, immediately spend it to an unhinted puzzle hash that we have manually added to the DB
+    # We should pick up this coin as balance even though it is unhinted because it is "change"
+    intermediate_sk_un = master_sk_to_wallet_sk_unhardened_intermediate(wallet_node_0.wallet_state_manager.private_key)
+    pubkey_unhardened = _derive_path_unhardened(intermediate_sk_un, [100000000]).get_g1()
+    inner_puzhash = puzzle_hash_for_pk(pubkey_unhardened)
+    puzzlehash_unhardened = construct_cat_puzzle(
+        CAT_MOD, Program.to(None).get_tree_hash(), inner_puzhash
+    ).get_tree_hash_precalc(inner_puzhash)
+    change_derivation = DerivationRecord(
+        uint32(0), puzzlehash_unhardened, pubkey_unhardened, WalletType.CAT, uint32(2), False
     )
-    @pytest.mark.anyio
-    async def test_cat_change_detection(
-        self, self_hostname: str, one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices, trusted: bool
-    ) -> None:
-        num_blocks = 1
-        full_nodes, wallets, bt = one_wallet_and_one_simulator_services
-        full_node_api: FullNodeSimulator = full_nodes[0]._api
-        full_node_server = full_node_api.full_node.server
-        wallet_service_0 = wallets[0]
-        wallet_node_0 = wallet_service_0._node
-        wallet_0 = wallet_node_0.wallet_state_manager.main_wallet
-        assert wallet_service_0.rpc_server is not None
-        client_0 = await WalletRpcClient.create(
-            bt.config["self_hostname"],
-            wallet_service_0.rpc_server.listen_port,
-            wallet_service_0.root_path,
-            wallet_service_0.config,
-        )
-        wallet_node_0.config["automatically_add_unknown_cats"] = True
-        if trusted:
-            wallet_node_0.config["trusted_peers"] = {
-                full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()
-            }
-        else:
-            wallet_node_0.config["trusted_peers"] = {}
-        await wallet_node_0.server.start_client(PeerInfo(self_hostname, uint16(full_node_server.get_port())), None)
-        await full_node_api.farm_blocks_to_wallet(count=num_blocks, wallet=wallet_0)
-        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node_0, timeout=20)
-        # Mint CAT to ourselves, immediately spend it to an unhinted puzzle hash that we have manually added to the DB
-        # We should pick up this coin as balance even though it is unhinted because it is "change"
-        intermediate_sk_un = master_sk_to_wallet_sk_unhardened_intermediate(
-            wallet_node_0.wallet_state_manager.private_key
-        )
-        pubkey_unhardened = _derive_path_unhardened(intermediate_sk_un, [100000000]).get_g1()
-        inner_puzhash = puzzle_hash_for_pk(pubkey_unhardened)
-        puzzlehash_unhardened = construct_cat_puzzle(
-            CAT_MOD,
-            Program.to(None).get_tree_hash(),
-            inner_puzhash,  # type: ignore[arg-type]
-        ).get_tree_hash_precalc(inner_puzhash)
-        change_derivation = DerivationRecord(
-            uint32(0),
-            puzzlehash_unhardened,
-            pubkey_unhardened,
-            WalletType.CAT,
-            uint32(2),
-            False,
-        )
-        # Insert the derivation record before the wallet exists so that it is not subscribed to
-        await wallet_node_0.wallet_state_manager.puzzle_store.add_derivation_paths([change_derivation])
-        our_puzzle: Program = await wallet_0.get_new_puzzle()
-        cat_puzzle: Program = construct_cat_puzzle(
-            CAT_MOD,
-            Program.to(None).get_tree_hash(),
-            Program.to(1),
-        )
-        addr = encode_puzzle_hash(cat_puzzle.get_tree_hash(), "txch")
-        cat_amount_0 = uint64(100)
-        cat_amount_1 = uint64(5)
-        tx = await client_0.send_transaction(1, cat_amount_0, addr, DEFAULT_TX_CONFIG)
-        spend_bundle = tx.spend_bundle
-        assert spend_bundle is not None
-        await time_out_assert_not_none(5, full_node_api.full_node.mempool_manager.get_spendbundle, spend_bundle.name())
-        await full_node_api.farm_blocks_to_wallet(count=num_blocks, wallet=wallet_0)
-        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node_0, timeout=20)
-        # Do the eve spend back to our wallet and add the CR layer
-        cat_coin = next(c for c in spend_bundle.additions() if c.amount == cat_amount_0)
-        next_coin = Coin(
-            cat_coin.name(),
-            construct_cat_puzzle(
-                CAT_MOD,
-                Program.to(None).get_tree_hash(),
-                our_puzzle,
-            ).get_tree_hash(),
-            cat_amount_0,
-        )
-        eve_spend = await wallet_node_0.wallet_state_manager.sign_transaction(
-            [
-                CoinSpend(
-                    cat_coin,
-                    cat_puzzle,
-                    Program.to(
+    # Insert the derivation record before the wallet exists so that it is not subscribed to
+    await wallet_node_0.wallet_state_manager.puzzle_store.add_derivation_paths([change_derivation])
+    our_puzzle = await wallet_0.get_new_puzzle()
+    cat_puzzle = construct_cat_puzzle(
+        CAT_MOD,
+        Program.to(None).get_tree_hash(),
+        Program.to(1),
+    )
+    addr = encode_puzzle_hash(cat_puzzle.get_tree_hash(), "txch")
+    cat_amount_0 = uint64(100)
+    cat_amount_1 = uint64(5)
+    tx = await client_0.send_transaction(1, cat_amount_0, addr, DEFAULT_TX_CONFIG)
+    spend_bundle = tx.spend_bundle
+    assert spend_bundle is not None
+    await time_out_assert_not_none(5, full_node_api.full_node.mempool_manager.get_spendbundle, spend_bundle.name())
+    await full_node_api.farm_blocks_to_wallet(count=num_blocks, wallet=wallet_0)
+    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node_0, timeout=20)
+    # Do the eve spend back to our wallet and add the CR layer
+    cat_coin = next(c for c in spend_bundle.additions() if c.amount == cat_amount_0)
+    next_coin = Coin(
+        cat_coin.name(),
+        construct_cat_puzzle(CAT_MOD, Program.to(None).get_tree_hash(), our_puzzle).get_tree_hash(),
+        cat_amount_0,
+    )
+    eve_spend, _ = await wallet_node_0.wallet_state_manager.sign_bundle(
+        [
+            make_spend(
+                cat_coin,
+                cat_puzzle,
+                Program.to(
+                    [
+                        Program.to(
+                            [
+                                [51, our_puzzle.get_tree_hash(), cat_amount_0, [our_puzzle.get_tree_hash()]],
+                                [51, None, -113, None, None],
+                            ]
+                        ),
+                        None,
+                        cat_coin.name(),
+                        coin_as_list(cat_coin),
+                        [cat_coin.parent_coin_info, Program.to(1).get_tree_hash(), cat_coin.amount],
+                        0,
+                        0,
+                    ]
+                ),
+            ),
+            make_spend(
+                next_coin,
+                construct_cat_puzzle(CAT_MOD, Program.to(None).get_tree_hash(), our_puzzle),
+                Program.to(
+                    [
                         [
-                            Program.to(
+                            None,
+                            (
+                                1,
                                 [
-                                    [
-                                        51,
-                                        our_puzzle.get_tree_hash(),
-                                        cat_amount_0,
-                                        [our_puzzle.get_tree_hash()],
-                                    ],
-                                    [51, None, -113, None, None],
-                                ]
+                                    [51, inner_puzhash, cat_amount_1],
+                                    [51, bytes32([0] * 32), cat_amount_0 - cat_amount_1],
+                                ],
                             ),
                             None,
-                            cat_coin.name(),
-                            coin_as_list(cat_coin),
-                            [cat_coin.parent_coin_info, Program.to(1).get_tree_hash(), cat_coin.amount],
-                            0,
-                            0,
-                        ]
-                    ),
-                ),
-                CoinSpend(
-                    next_coin,
-                    construct_cat_puzzle(
-                        CAT_MOD,
-                        Program.to(None).get_tree_hash(),
-                        our_puzzle,
-                    ),
-                    Program.to(
-                        [
-                            [
-                                None,
-                                (
-                                    1,
-                                    [
-                                        [51, inner_puzhash, cat_amount_1],
-                                        [51, bytes32([0] * 32), cat_amount_0 - cat_amount_1],
-                                    ],
-                                ),
-                                None,
-                            ],
-                            LineageProof(
-                                cat_coin.parent_coin_info, Program.to(1).get_tree_hash(), cat_amount_0
-                            ).to_program(),
-                            next_coin.name(),
-                            coin_as_list(next_coin),
-                            [next_coin.parent_coin_info, our_puzzle.get_tree_hash(), next_coin.amount],
-                            0,
-                            0,
-                        ]
-                    ),
+                        ],
+                        LineageProof(
+                            cat_coin.parent_coin_info, Program.to(1).get_tree_hash(), cat_amount_0
+                        ).to_program(),
+                        next_coin.name(),
+                        coin_as_list(next_coin),
+                        [next_coin.parent_coin_info, our_puzzle.get_tree_hash(), next_coin.amount],
+                        0,
+                        0,
+                    ]
                 ),
-            ],
-        )
-        await client_0.push_tx(eve_spend)
-        await time_out_assert_not_none(5, full_node_api.full_node.mempool_manager.get_spendbundle, eve_spend.name())
-        await full_node_api.farm_blocks_to_wallet(count=num_blocks, wallet=wallet_0)
-        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node_0, timeout=20)
-        async def check_wallets(node):
-            return len(node.wallet_state_manager.wallets.keys())
+            ),
+        ],
+    )
+    await client_0.push_tx(eve_spend)
+    await time_out_assert_not_none(5, full_node_api.full_node.mempool_manager.get_spendbundle, eve_spend.name())
+    await full_node_api.farm_blocks_to_wallet(count=num_blocks, wallet=wallet_0)
+    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node_0, timeout=20)
-        await time_out_assert(20, check_wallets, 2, wallet_node_0)
-        cat_wallet = wallet_node_0.wallet_state_manager.wallets[uint32(2)]
-        await time_out_assert(20, cat_wallet.get_confirmed_balance, cat_amount_1)
-        assert not full_node_api.full_node.subscriptions.has_ph_subscription(puzzlehash_unhardened)
+    await time_out_assert(20, check_wallets, 2, wallet_node_0)
+    cat_wallet = wallet_node_0.wallet_state_manager.wallets[uint32(2)]
+    await time_out_assert(20, cat_wallet.get_confirmed_balance, cat_amount_1)
+    assert not full_node_api.full_node.subscriptions.has_puzzle_subscription(puzzlehash_unhardened)
 @pytest.mark.anyio

tests/wallet/cat_wallet/test_offer_lifecycle.py CHANGED Viewed

         @@@ -67,8 -66,8 +67,8 @@@ async def generate_coins
                         CAT_MOD,
                         [
                             SpendableCAT(
-                                Coin(parent_coin.name(), cat_puzzle_hash, amount),
-                                Coin(parent_coin.name(), cat_puzzle.get_tree_hash(), amount),
-                                tail.get_tree_hash(),
+                                Coin(parent_coin.name(), cat_puzzle_hash, uint64(amount)),
+                                tail_hash,
                                 acs,
                                 Program.to([[51, acs_ph, amount], [51, 0, -113, tail, []]]),
                             )

tests/wallet/cat_wallet/test_trades.py CHANGED Viewed

         @@@ -1552,439 -1511,457 +1552,442 @@@ async def test_cat_trades
         assert result.error is None
-@pytest.mark.parametrize(
-    "trusted",
-    [True, False],
-)
-class TestCATTrades:
-    @pytest.mark.anyio
-    async def test_trade_cancellation(self, wallets_prefarm):
-        (
-            [wallet_node_maker, maker_funds],
-            [wallet_node_taker, taker_funds],
-            full_node,
-        ) = wallets_prefarm
-        wallet_maker = wallet_node_maker.wallet_state_manager.main_wallet
-        wallet_taker = wallet_node_taker.wallet_state_manager.main_wallet
+@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.anyio
+async def test_trade_cancellation(wallets_prefarm):
+    (
+        [wallet_node_maker, maker_funds],
+        [wallet_node_taker, taker_funds],
+        full_node,
+    ) = wallets_prefarm
+    wallet_maker = wallet_node_maker.wallet_state_manager.main_wallet
+    wallet_taker = wallet_node_taker.wallet_state_manager.main_wallet
+    xch_to_cat_amount = uint64(100)
+    async with wallet_node_maker.wallet_state_manager.lock:
+        cat_wallet_maker, tx_records = await CATWallet.create_new_cat_wallet(
+            wallet_node_maker.wallet_state_manager,
+            wallet_maker,
+            {"identifier": "genesis_by_id"},
+            xch_to_cat_amount,
+            DEFAULT_TX_CONFIG,
+        )
-        xch_to_cat_amount = uint64(100)
+    await full_node.process_transaction_records(records=tx_records)
-        async with wallet_node_maker.wallet_state_manager.lock:
-            cat_wallet_maker, _ = await CATWallet.create_new_cat_wallet(
-                wallet_node_maker.wallet_state_manager,
-                wallet_maker,
-                {"identifier": "genesis_by_id"},
-                xch_to_cat_amount,
-                DEFAULT_TX_CONFIG,
-            )
+    await time_out_assert(15, cat_wallet_maker.get_confirmed_balance, xch_to_cat_amount)
+    await time_out_assert(15, cat_wallet_maker.get_unconfirmed_balance, xch_to_cat_amount)
+    maker_funds -= xch_to_cat_amount
+    await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds)
-            tx_records: List[TransactionRecord] = await wallet_node_maker.wallet_state_manager.tx_store.get_not_sent()
+    cat_for_chia = {
+        wallet_maker.id(): 1,
+        cat_wallet_maker.id(): -2,
+    }
-        await full_node.process_transaction_records(records=tx_records)
+    chia_for_cat = {
+        wallet_maker.id(): -3,
+        cat_wallet_maker.id(): 4,
+    }
-        await time_out_assert(15, cat_wallet_maker.get_confirmed_balance, xch_to_cat_amount)
-        await time_out_assert(15, cat_wallet_maker.get_unconfirmed_balance, xch_to_cat_amount)
-        maker_funds -= xch_to_cat_amount
-        await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds)
+    trade_manager_maker = wallet_node_maker.wallet_state_manager.trade_manager
+    trade_manager_taker = wallet_node_taker.wallet_state_manager.trade_manager
-        cat_for_chia = {
-            wallet_maker.id(): 1,
-            cat_wallet_maker.id(): -2,
-        }
+    success, trade_make, _, error = await trade_manager_maker.create_offer_for_ids(cat_for_chia, DEFAULT_TX_CONFIG)
+    assert error is None
+    assert success is True
+    assert trade_make is not None
-        chia_for_cat = {
-            wallet_maker.id(): -3,
-            cat_wallet_maker.id(): 4,
-        }
+    # Cancelling the trade and trying an ID that doesn't exist just in case
+    await trade_manager_maker.cancel_pending_offers(
+        [trade_make.trade_id, bytes32([0] * 32)], DEFAULT_TX_CONFIG, secure=False
+    )
+    await time_out_assert(15, get_trade_and_status, TradeStatus.CANCELLED, trade_manager_maker, trade_make)
+    # Due to current mempool rules, trying to force a take out of the mempool with a cancel will not work.
+    # Uncomment this when/if it does
+    # [maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
+    #   [Offer.from_bytes(trade_make.offer)]
+    # )
+    # trade_take, tx_records = await trade_manager_taker.respond_to_offer(
+    #     maker_offer,
+    # )
+    # tx_records = await wallet_taker.wallet_state_manager.add_pending_transactions(
+    #   tx_records,
+    #   additional_signing_responses=signing_response,
+    # )
+    # await time_out_assert(15, full_node.txs_in_mempool, True, tx_records)
+    # assert trade_take is not None
+    # assert tx_records is not None
+    # await time_out_assert(15, get_trade_and_status, TradeStatus.PENDING_CONFIRM, trade_manager_taker, trade_take)
+    # await time_out_assert(
+    #     15,
+    #     full_node.tx_id_in_mempool,
+    #     True,
+    #     Offer.from_bytes(trade_take.offer).to_valid_spend().name(),
+    # )
+    fee = uint64(2_000_000_000_000)
+    txs = await trade_manager_maker.cancel_pending_offers(
+        [trade_make.trade_id], DEFAULT_TX_CONFIG, fee=fee, secure=True
+    )
+    txs = await wallet_maker.wallet_state_manager.add_pending_transactions(txs)
+    await time_out_assert(15, get_trade_and_status, TradeStatus.PENDING_CANCEL, trade_manager_maker, trade_make)
+    await full_node.process_transaction_records(records=txs)
+    sum_of_outgoing = uint64(0)
+    sum_of_incoming = uint64(0)
+    for tx in txs:
+        if tx.type == TransactionType.OUTGOING_TX.value:
+            sum_of_outgoing = uint64(sum_of_outgoing + tx.amount)
+        elif tx.type == TransactionType.INCOMING_TX.value:
+            sum_of_incoming = uint64(sum_of_incoming + tx.amount)
+    assert (sum_of_outgoing - sum_of_incoming) == 0
+    await time_out_assert(15, get_trade_and_status, TradeStatus.CANCELLED, trade_manager_maker, trade_make)
+    # await time_out_assert(15, get_trade_and_status, TradeStatus.FAILED, trade_manager_taker, trade_take)
+    await time_out_assert(15, wallet_maker.get_pending_change_balance, 0)
+    await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds - fee)
+    await time_out_assert(15, cat_wallet_maker.get_confirmed_balance, xch_to_cat_amount)
+    await time_out_assert(15, wallet_taker.get_confirmed_balance, taker_funds)
-        trade_manager_maker = wallet_node_maker.wallet_state_manager.trade_manager
-        trade_manager_taker = wallet_node_taker.wallet_state_manager.trade_manager
+    peer = wallet_node_taker.get_full_node_peer()
+    with pytest.raises(ValueError, match="This offer is no longer valid"):
+        await trade_manager_taker.respond_to_offer(Offer.from_bytes(trade_make.offer), peer, DEFAULT_TX_CONFIG)
-        async def get_trade_and_status(trade_manager, trade) -> TradeStatus:
-            trade_rec = await trade_manager.get_trade_by_id(trade.trade_id)
-            return TradeStatus(trade_rec.status)
+    # Now we're going to create the other way around for test coverage sake
+    success, trade_make, _, error = await trade_manager_maker.create_offer_for_ids(chia_for_cat, DEFAULT_TX_CONFIG)
+    assert error is None
+    assert success is True
+    assert trade_make is not None
-        success, trade_make, _, error = await trade_manager_maker.create_offer_for_ids(cat_for_chia, DEFAULT_TX_CONFIG)
-        assert error is None
-        assert success is True
-        assert trade_make is not None
+    # This take should fail since we have no CATs to fulfill it with
+    with pytest.raises(
+        ValueError,
+        match=f"Do not have a wallet for asset ID: {cat_wallet_maker.get_asset_id()} to fulfill offer",
+    ):
+        await trade_manager_taker.respond_to_offer(Offer.from_bytes(trade_make.offer), peer, DEFAULT_TX_CONFIG)
-        # Cancelling the trade and trying an ID that doesn't exist just in case
-        await trade_manager_maker.cancel_pending_offers(
-            [trade_make.trade_id, bytes32([0] * 32)], DEFAULT_TX_CONFIG, secure=False
-        )
-        await time_out_assert(15, get_trade_and_status, TradeStatus.CANCELLED, trade_manager_maker, trade_make)
-        # Due to current mempool rules, trying to force a take out of the mempool with a cancel will not work.
-        # Uncomment this when/if it does
-        # trade_take, tx_records = await trade_manager_taker.respond_to_offer(
-        #     Offer.from_bytes(trade_make.offer),
-        # )
-        # await wallet_taker.wallet_state_manager.add_pending_transactions(tx_records)
-        # await time_out_assert(15, full_node.txs_in_mempool, True, tx_records)
-        # assert trade_take is not None
-        # assert tx_records is not None
-        # await time_out_assert(15, get_trade_and_status, TradeStatus.PENDING_CONFIRM, trade_manager_taker, trade_take)
-        # await time_out_assert(
-        #     15,
-        #     full_node.tx_id_in_mempool,
-        #     True,
-        #     Offer.from_bytes(trade_take.offer).to_valid_spend().name(),
-        # )
-        fee = uint64(2_000_000_000_000)
-        txs = await trade_manager_maker.cancel_pending_offers(
-            [trade_make.trade_id], DEFAULT_TX_CONFIG, fee=fee, secure=True
-        )
-        await wallet_taker.wallet_state_manager.add_pending_transactions(txs)
-        await time_out_assert(15, get_trade_and_status, TradeStatus.PENDING_CANCEL, trade_manager_maker, trade_make)
-        await full_node.process_transaction_records(records=txs)
-        sum_of_outgoing = uint64(0)
-        sum_of_incoming = uint64(0)
-        for tx in txs:
-            if tx.type == TransactionType.OUTGOING_TX.value:
-                sum_of_outgoing = uint64(sum_of_outgoing + tx.amount)
-            elif tx.type == TransactionType.INCOMING_TX.value:
-                sum_of_incoming = uint64(sum_of_incoming + tx.amount)
-        assert (sum_of_outgoing - sum_of_incoming) == 0
-        await time_out_assert(15, get_trade_and_status, TradeStatus.CANCELLED, trade_manager_maker, trade_make)
-        # await time_out_assert(15, get_trade_and_status, TradeStatus.FAILED, trade_manager_taker, trade_take)
-        await time_out_assert(15, wallet_maker.get_pending_change_balance, 0)
-        await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds - fee)
-        await time_out_assert(15, cat_wallet_maker.get_confirmed_balance, xch_to_cat_amount)
-        await time_out_assert(15, wallet_taker.get_confirmed_balance, taker_funds)
-        peer = wallet_node_taker.get_full_node_peer()
-        with pytest.raises(ValueError, match="This offer is no longer valid"):
-            await trade_manager_taker.respond_to_offer(Offer.from_bytes(trade_make.offer), peer, DEFAULT_TX_CONFIG)
-        # Now we're going to create the other way around for test coverage sake
-        success, trade_make, _, error = await trade_manager_maker.create_offer_for_ids(chia_for_cat, DEFAULT_TX_CONFIG)
-        assert error is None
-        assert success is True
-        assert trade_make is not None
-        # This take should fail since we have no CATs to fulfill it with
-        with pytest.raises(
-            ValueError,
-            match=f"Do not have a wallet for asset ID: {cat_wallet_maker.get_asset_id()} to fulfill offer",
-        ):
-            await trade_manager_taker.respond_to_offer(Offer.from_bytes(trade_make.offer), peer, DEFAULT_TX_CONFIG)
-        txs = await trade_manager_maker.cancel_pending_offers(
-            [trade_make.trade_id], DEFAULT_TX_CONFIG, fee=uint64(0), secure=True
-        )
-        await wallet_taker.wallet_state_manager.add_pending_transactions(txs)
-        await time_out_assert(15, get_trade_and_status, TradeStatus.PENDING_CANCEL, trade_manager_maker, trade_make)
-        await full_node.process_transaction_records(records=txs)
+    txs = await trade_manager_maker.cancel_pending_offers(
+        [trade_make.trade_id], DEFAULT_TX_CONFIG, fee=uint64(0), secure=True
+    )
+    txs = await wallet_maker.wallet_state_manager.add_pending_transactions(txs)
+    await time_out_assert(15, get_trade_and_status, TradeStatus.PENDING_CANCEL, trade_manager_maker, trade_make)
+    await full_node.process_transaction_records(records=txs)
-        await time_out_assert(15, get_trade_and_status, TradeStatus.CANCELLED, trade_manager_maker, trade_make)
+    await time_out_assert(15, get_trade_and_status, TradeStatus.CANCELLED, trade_manager_maker, trade_make)
-    @pytest.mark.anyio
-    async def test_trade_cancellation_balance_check(self, wallets_prefarm):
-        (
-            [wallet_node_maker, maker_funds],
-            [wallet_node_taker, taker_funds],
-            full_node,
-        ) = wallets_prefarm
-        wallet_maker = wallet_node_maker.wallet_state_manager.main_wallet
-        xch_to_cat_amount = uint64(100)
+@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.anyio
+async def test_trade_cancellation_balance_check(wallets_prefarm):
+    (
+        [wallet_node_maker, maker_funds],
+        [wallet_node_taker, taker_funds],
+        full_node,
+    ) = wallets_prefarm
+    wallet_maker = wallet_node_maker.wallet_state_manager.main_wallet
+    xch_to_cat_amount = uint64(100)
+    async with wallet_node_maker.wallet_state_manager.lock:
+        cat_wallet_maker, tx_records = await CATWallet.create_new_cat_wallet(
+            wallet_node_maker.wallet_state_manager,
+            wallet_maker,
+            {"identifier": "genesis_by_id"},
+            xch_to_cat_amount,
+            DEFAULT_TX_CONFIG,
+        )
-        async with wallet_node_maker.wallet_state_manager.lock:
-            cat_wallet_maker, _ = await CATWallet.create_new_cat_wallet(
-                wallet_node_maker.wallet_state_manager,
-                wallet_maker,
-                {"identifier": "genesis_by_id"},
-                xch_to_cat_amount,
-                DEFAULT_TX_CONFIG,
-            )
+    await full_node.process_transaction_records(records=tx_records)
-            tx_records: List[TransactionRecord] = await wallet_node_maker.wallet_state_manager.tx_store.get_not_sent()
+    await time_out_assert(15, cat_wallet_maker.get_confirmed_balance, xch_to_cat_amount)
+    await time_out_assert(15, cat_wallet_maker.get_unconfirmed_balance, xch_to_cat_amount)
+    maker_funds -= xch_to_cat_amount
+    await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds)
-        await full_node.process_transaction_records(records=tx_records)
+    chia_for_cat = {
+        wallet_maker.id(): -(await wallet_maker.get_spendable_balance()),
+        cat_wallet_maker.id(): 4,
+    }
-        await time_out_assert(15, cat_wallet_maker.get_confirmed_balance, xch_to_cat_amount)
-        await time_out_assert(15, cat_wallet_maker.get_unconfirmed_balance, xch_to_cat_amount)
-        maker_funds -= xch_to_cat_amount
-        await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds)
+    trade_manager_maker = wallet_node_maker.wallet_state_manager.trade_manager
-        chia_for_cat = {
-            wallet_maker.id(): -(await wallet_maker.get_spendable_balance()),
-            cat_wallet_maker.id(): 4,
-        }
+    success, trade_make, _, error = await trade_manager_maker.create_offer_for_ids(chia_for_cat, DEFAULT_TX_CONFIG)
+    await time_out_assert(10, get_trade_and_status, TradeStatus.PENDING_ACCEPT, trade_manager_maker, trade_make)
+    assert error is None
+    assert success is True
+    assert trade_make is not None
+    txs = await trade_manager_maker.cancel_pending_offers(
+        [trade_make.trade_id], DEFAULT_TX_CONFIG, fee=uint64(0), secure=True
+    )
+    txs = await trade_manager_maker.wallet_state_manager.add_pending_transactions(txs)
+    await time_out_assert(15, get_trade_and_status, TradeStatus.PENDING_CANCEL, trade_manager_maker, trade_make)
+    await full_node.process_transaction_records(records=txs)
-        trade_manager_maker = wallet_node_maker.wallet_state_manager.trade_manager
+    await time_out_assert(15, get_trade_and_status, TradeStatus.CANCELLED, trade_manager_maker, trade_make)
-        async def get_trade_and_status(trade_manager, trade) -> TradeStatus:
-            trade_rec = await trade_manager.get_trade_by_id(trade.trade_id)
-            return TradeStatus(trade_rec.status)
-        success, trade_make, _, error = await trade_manager_maker.create_offer_for_ids(chia_for_cat, DEFAULT_TX_CONFIG)
-        await time_out_assert(10, get_trade_and_status, TradeStatus.PENDING_ACCEPT, trade_manager_maker, trade_make)
-        assert error is None
-        assert success is True
-        assert trade_make is not None
-        txs = await trade_manager_maker.cancel_pending_offers(
-            [trade_make.trade_id], DEFAULT_TX_CONFIG, fee=uint64(0), secure=True
+@pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN, ConsensusMode.HARD_FORK_2_0], reason="save time")
+@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.anyio
+async def test_trade_conflict(three_wallets_prefarm):
+    (
+        [wallet_node_maker, maker_funds],
+        [wallet_node_taker, taker_funds],
+        [wallet_node_trader, trader_funds],
+        full_node,
+    ) = three_wallets_prefarm
+    wallet_maker = wallet_node_maker.wallet_state_manager.main_wallet
+    xch_to_cat_amount = uint64(100)
+    async with wallet_node_maker.wallet_state_manager.lock:
+        cat_wallet_maker, tx_records = await CATWallet.create_new_cat_wallet(
+            wallet_node_maker.wallet_state_manager,
+            wallet_maker,
+            {"identifier": "genesis_by_id"},
+            xch_to_cat_amount,
+            DEFAULT_TX_CONFIG,
         )
-        await trade_manager_maker.wallet_state_manager.add_pending_transactions(txs)
-        await time_out_assert(15, get_trade_and_status, TradeStatus.PENDING_CANCEL, trade_manager_maker, trade_make)
-        await full_node.process_transaction_records(records=txs)
-        await time_out_assert(15, get_trade_and_status, TradeStatus.CANCELLED, trade_manager_maker, trade_make)
+    await full_node.process_transaction_records(records=tx_records)
-    @pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN, ConsensusMode.HARD_FORK_2_0], reason="save time")
-    @pytest.mark.anyio
-    async def test_trade_conflict(self, three_wallets_prefarm):
-        (
-            [wallet_node_maker, maker_funds],
-            [wallet_node_taker, taker_funds],
-            [wallet_node_trader, trader_funds],
-            full_node,
-        ) = three_wallets_prefarm
-        wallet_maker = wallet_node_maker.wallet_state_manager.main_wallet
-        xch_to_cat_amount = uint64(100)
+    await time_out_assert(15, cat_wallet_maker.get_confirmed_balance, xch_to_cat_amount)
+    await time_out_assert(15, cat_wallet_maker.get_unconfirmed_balance, xch_to_cat_amount)
+    maker_funds -= xch_to_cat_amount
+    await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds)
-        async with wallet_node_maker.wallet_state_manager.lock:
-            cat_wallet_maker, _ = await CATWallet.create_new_cat_wallet(
-                wallet_node_maker.wallet_state_manager,
-                wallet_maker,
-                {"identifier": "genesis_by_id"},
-                xch_to_cat_amount,
-                DEFAULT_TX_CONFIG,
-            )
-            tx_records: List[TransactionRecord] = await wallet_node_maker.wallet_state_manager.tx_store.get_not_sent()
+    chia_for_cat = {
+        wallet_maker.id(): 1000,
+        cat_wallet_maker.id(): -4,
+    }
-        await full_node.process_transaction_records(records=tx_records)
+    trade_manager_maker = wallet_node_maker.wallet_state_manager.trade_manager
+    trade_manager_taker = wallet_node_taker.wallet_state_manager.trade_manager
+    trade_manager_trader = wallet_node_trader.wallet_state_manager.trade_manager
-        await time_out_assert(15, cat_wallet_maker.get_confirmed_balance, xch_to_cat_amount)
-        await time_out_assert(15, cat_wallet_maker.get_unconfirmed_balance, xch_to_cat_amount)
-        maker_funds -= xch_to_cat_amount
-        await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds)
+    success, trade_make, _, error = await trade_manager_maker.create_offer_for_ids(chia_for_cat, DEFAULT_TX_CONFIG)
+    await time_out_assert(10, get_trade_and_status, TradeStatus.PENDING_ACCEPT, trade_manager_maker, trade_make)
+    assert error is None
+    assert success is True
+    assert trade_make is not None
+    peer = wallet_node_taker.get_full_node_peer()
+    offer = Offer.from_bytes(trade_make.offer)
+    [offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers([offer])
+    tr1, txs1 = await trade_manager_taker.respond_to_offer(offer, peer, DEFAULT_TX_CONFIG, fee=uint64(10))
+    txs1 = await trade_manager_taker.wallet_state_manager.add_pending_transactions(
+        txs1, additional_signing_responses=signing_response
+    )
+    await full_node.wait_transaction_records_entered_mempool(records=txs1)
+    # we shouldn't be able to respond to a duplicate offer
+    with pytest.raises(ValueError):
+        await trade_manager_taker.respond_to_offer(offer, peer, DEFAULT_TX_CONFIG, fee=uint64(10))
+    await time_out_assert(15, get_trade_and_status, TradeStatus.PENDING_CONFIRM, trade_manager_taker, tr1)
+    # pushing into mempool while already in it should fail
+    [offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers([offer])
+    tr2, txs2 = await trade_manager_trader.respond_to_offer(offer, peer, DEFAULT_TX_CONFIG, fee=uint64(10))
+    txs2 = await trade_manager_taker.wallet_state_manager.add_pending_transactions(
+        txs2, additional_signing_responses=signing_response
+    )
+    await trade_manager_trader.wallet_state_manager.add_pending_transactions(txs2)
+    assert await trade_manager_trader.get_coins_of_interest()
+    offer_tx_records: List[TransactionRecord] = await wallet_node_maker.wallet_state_manager.tx_store.get_not_sent()
+    await full_node.process_transaction_records(records=offer_tx_records)
+    await full_node.wait_for_wallet_synced(wallet_node=wallet_node_trader, timeout=20)
+    await time_out_assert(15, get_trade_and_status, TradeStatus.FAILED, trade_manager_trader, tr2)
-        chia_for_cat = {
-            wallet_maker.id(): 1000,
-            cat_wallet_maker.id(): -4,
-        }
-        trade_manager_maker = wallet_node_maker.wallet_state_manager.trade_manager
-        trade_manager_taker = wallet_node_taker.wallet_state_manager.trade_manager
-        trade_manager_trader = wallet_node_trader.wallet_state_manager.trade_manager
-        async def get_trade_and_status(trade_manager, trade) -> TradeStatus:
-            trade_rec = await trade_manager.get_trade_by_id(trade.trade_id)
-            if trade_rec:
-                return TradeStatus(trade_rec.status)
-            raise ValueError("Couldn't find the trade record")
-        success, trade_make, _, error = await trade_manager_maker.create_offer_for_ids(chia_for_cat, DEFAULT_TX_CONFIG)
-        await time_out_assert(10, get_trade_and_status, TradeStatus.PENDING_ACCEPT, trade_manager_maker, trade_make)
-        assert error is None
-        assert success is True
-        assert trade_make is not None
-        peer = wallet_node_taker.get_full_node_peer()
-        offer = Offer.from_bytes(trade_make.offer)
-        tr1, txs1 = await trade_manager_taker.respond_to_offer(offer, peer, DEFAULT_TX_CONFIG, fee=uint64(10))
-        await trade_manager_taker.wallet_state_manager.add_pending_transactions(txs1)
-        # we shouldn't be able to respond to a duplicate offer
-        with pytest.raises(ValueError):
-            await trade_manager_taker.respond_to_offer(offer, peer, DEFAULT_TX_CONFIG, fee=uint64(10))
-        await time_out_assert(15, get_trade_and_status, TradeStatus.PENDING_CONFIRM, trade_manager_taker, tr1)
-        # pushing into mempool while already in it should fail
-        tr2, txs2 = await trade_manager_trader.respond_to_offer(offer, peer, DEFAULT_TX_CONFIG, fee=uint64(10))
-        await trade_manager_taker.wallet_state_manager.add_pending_transactions(txs2)
-        assert await trade_manager_trader.get_coins_of_interest()
-        offer_tx_records: List[TransactionRecord] = await wallet_node_maker.wallet_state_manager.tx_store.get_not_sent()
-        await full_node.process_transaction_records(records=offer_tx_records)
-        await time_out_assert(15, get_trade_and_status, TradeStatus.FAILED, trade_manager_trader, tr2)
-    @pytest.mark.anyio
-    async def test_trade_bad_spend(self, wallets_prefarm):
-        (
-            [wallet_node_maker, maker_funds],
-            [wallet_node_taker, taker_funds],
-            full_node,
-        ) = wallets_prefarm
-        wallet_maker = wallet_node_maker.wallet_state_manager.main_wallet
-        xch_to_cat_amount = uint64(100)
+@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.anyio
+async def test_trade_bad_spend(wallets_prefarm):
+    (
+        [wallet_node_maker, maker_funds],
+        [wallet_node_taker, taker_funds],
+        full_node,
+    ) = wallets_prefarm
+    wallet_maker = wallet_node_maker.wallet_state_manager.main_wallet
+    xch_to_cat_amount = uint64(100)
+    async with wallet_node_maker.wallet_state_manager.lock:
+        cat_wallet_maker, tx_records = await CATWallet.create_new_cat_wallet(
+            wallet_node_maker.wallet_state_manager,
+            wallet_maker,
+            {"identifier": "genesis_by_id"},
+            xch_to_cat_amount,
+            DEFAULT_TX_CONFIG,
+        )
-        async with wallet_node_maker.wallet_state_manager.lock:
-            cat_wallet_maker, _ = await CATWallet.create_new_cat_wallet(
-                wallet_node_maker.wallet_state_manager,
-                wallet_maker,
-                {"identifier": "genesis_by_id"},
-                xch_to_cat_amount,
-                DEFAULT_TX_CONFIG,
-            )
+    await full_node.process_transaction_records(records=tx_records)
-            tx_records: List[TransactionRecord] = await wallet_node_maker.wallet_state_manager.tx_store.get_not_sent()
+    await time_out_assert(15, cat_wallet_maker.get_confirmed_balance, xch_to_cat_amount)
+    await time_out_assert(15, cat_wallet_maker.get_unconfirmed_balance, xch_to_cat_amount)
+    maker_funds -= xch_to_cat_amount
+    await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds)
-        await full_node.process_transaction_records(records=tx_records)
+    chia_for_cat = {
+        wallet_maker.id(): 1000,
+        cat_wallet_maker.id(): -4,
+    }
-        await time_out_assert(15, cat_wallet_maker.get_confirmed_balance, xch_to_cat_amount)
-        await time_out_assert(15, cat_wallet_maker.get_unconfirmed_balance, xch_to_cat_amount)
-        maker_funds -= xch_to_cat_amount
-        await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds)
+    trade_manager_maker = wallet_node_maker.wallet_state_manager.trade_manager
+    trade_manager_taker = wallet_node_taker.wallet_state_manager.trade_manager
-        chia_for_cat = {
-            wallet_maker.id(): 1000,
-            cat_wallet_maker.id(): -4,
-        }
+    success, trade_make, _, error = await trade_manager_maker.create_offer_for_ids(chia_for_cat, DEFAULT_TX_CONFIG)
+    await time_out_assert(30, get_trade_and_status, TradeStatus.PENDING_ACCEPT, trade_manager_maker, trade_make)
+    assert error is None
+    assert success is True
+    assert trade_make is not None
+    peer = wallet_node_taker.get_full_node_peer()
+    offer = Offer.from_bytes(trade_make.offer)
+    bundle = dataclasses.replace(offer._bundle, aggregated_signature=G2Element())
+    offer = dataclasses.replace(offer, _bundle=bundle)
+    tr1, txs1 = await trade_manager_taker.respond_to_offer(offer, peer, DEFAULT_TX_CONFIG, fee=uint64(10))
+    txs1 = await trade_manager_taker.wallet_state_manager.add_pending_transactions(txs1, sign=False)
+    wallet_node_taker.wallet_tx_resend_timeout_secs = 0  # don't wait for resend
-        trade_manager_maker = wallet_node_maker.wallet_state_manager.trade_manager
-        trade_manager_taker = wallet_node_taker.wallet_state_manager.trade_manager
-        async def get_trade_and_status(trade_manager, trade) -> TradeStatus:
-            trade_rec = await trade_manager.get_trade_by_id(trade.trade_id)
-            if trade_rec:
-                return TradeStatus(trade_rec.status)
-            raise ValueError("Couldn't find the trade record")
-        success, trade_make, _, error = await trade_manager_maker.create_offer_for_ids(chia_for_cat, DEFAULT_TX_CONFIG)
-        await time_out_assert(30, get_trade_and_status, TradeStatus.PENDING_ACCEPT, trade_manager_maker, trade_make)
-        assert error is None
-        assert success is True
-        assert trade_make is not None
-        peer = wallet_node_taker.get_full_node_peer()
-        offer = Offer.from_bytes(trade_make.offer)
-        bundle = dataclasses.replace(offer._bundle, aggregated_signature=G2Element())
-        offer = dataclasses.replace(offer, _bundle=bundle)
-        tr1, txs1 = await trade_manager_taker.respond_to_offer(offer, peer, DEFAULT_TX_CONFIG, fee=uint64(10))
-        await trade_manager_taker.wallet_state_manager.add_pending_transactions(txs1)
-        wallet_node_taker.wallet_tx_resend_timeout_secs = 0  # don't wait for resend
-        def check_wallet_cache_empty() -> bool:
-            return wallet_node_taker._tx_messages_in_progress == {}
-        for _ in range(10):
-            print(await wallet_node_taker._resend_queue())
-            await time_out_assert(5, check_wallet_cache_empty, True)
-        offer_tx_records: List[TransactionRecord] = await wallet_node_maker.wallet_state_manager.tx_store.get_not_sent()
-        await full_node.process_transaction_records(records=offer_tx_records)
-        await time_out_assert(30, get_trade_and_status, TradeStatus.FAILED, trade_manager_taker, tr1)
-    @pytest.mark.anyio
-    async def test_trade_high_fee(self, wallets_prefarm):
-        (
-            [wallet_node_maker, maker_funds],
-            [wallet_node_taker, taker_funds],
-            full_node,
-        ) = wallets_prefarm
-        wallet_maker = wallet_node_maker.wallet_state_manager.main_wallet
-        xch_to_cat_amount = uint64(100)
+    def check_wallet_cache_empty() -> bool:
+        return wallet_node_taker._tx_messages_in_progress == {}
-        async with wallet_node_maker.wallet_state_manager.lock:
-            cat_wallet_maker, _ = await CATWallet.create_new_cat_wallet(
-                wallet_node_maker.wallet_state_manager,
-                wallet_maker,
-                {"identifier": "genesis_by_id"},
-                xch_to_cat_amount,
-                DEFAULT_TX_CONFIG,
-            )
+    for _ in range(10):
+        await wallet_node_taker._resend_queue()
+        await time_out_assert(5, check_wallet_cache_empty, True)
+    offer_tx_records: List[TransactionRecord] = await wallet_node_maker.wallet_state_manager.tx_store.get_not_sent()
+    await full_node.process_transaction_records(records=offer_tx_records)
+    await time_out_assert(30, get_trade_and_status, TradeStatus.FAILED, trade_manager_taker, tr1)
-            tx_records: List[TransactionRecord] = await wallet_node_maker.wallet_state_manager.tx_store.get_not_sent()
-        await full_node.process_transaction_records(records=tx_records)
+@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.anyio
+async def test_trade_high_fee(wallets_prefarm):
+    (
+        [wallet_node_maker, maker_funds],
+        [wallet_node_taker, taker_funds],
+        full_node,
+    ) = wallets_prefarm
+    wallet_maker = wallet_node_maker.wallet_state_manager.main_wallet
+    xch_to_cat_amount = uint64(100)
+    async with wallet_node_maker.wallet_state_manager.lock:
+        cat_wallet_maker, tx_records = await CATWallet.create_new_cat_wallet(
+            wallet_node_maker.wallet_state_manager,
+            wallet_maker,
+            {"identifier": "genesis_by_id"},
+            xch_to_cat_amount,
+            DEFAULT_TX_CONFIG,
+        )
-        await time_out_assert(15, cat_wallet_maker.get_confirmed_balance, xch_to_cat_amount)
-        await time_out_assert(15, cat_wallet_maker.get_unconfirmed_balance, xch_to_cat_amount)
-        maker_funds -= xch_to_cat_amount
-        await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds)
+    await full_node.process_transaction_records(records=tx_records)
-        chia_for_cat = {
-            wallet_maker.id(): 1000,
-            cat_wallet_maker.id(): -4,
-        }
+    await time_out_assert(15, cat_wallet_maker.get_confirmed_balance, xch_to_cat_amount)
+    await time_out_assert(15, cat_wallet_maker.get_unconfirmed_balance, xch_to_cat_amount)
+    maker_funds -= xch_to_cat_amount
+    await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds)
-        trade_manager_maker = wallet_node_maker.wallet_state_manager.trade_manager
-        trade_manager_taker = wallet_node_taker.wallet_state_manager.trade_manager
-        async def get_trade_and_status(trade_manager, trade) -> TradeStatus:
-            trade_rec = await trade_manager.get_trade_by_id(trade.trade_id)
-            if trade_rec:
-                return TradeStatus(trade_rec.status)
-            raise ValueError("Couldn't find the trade record")
-        success, trade_make, _, error = await trade_manager_maker.create_offer_for_ids(chia_for_cat, DEFAULT_TX_CONFIG)
-        await time_out_assert(10, get_trade_and_status, TradeStatus.PENDING_ACCEPT, trade_manager_maker, trade_make)
-        assert error is None
-        assert success is True
-        assert trade_make is not None
-        peer = wallet_node_taker.get_full_node_peer()
-        offer = Offer.from_bytes(trade_make.offer)
-        tr1, txs1 = await trade_manager_taker.respond_to_offer(
-            offer, peer, DEFAULT_TX_CONFIG, fee=uint64(1000000000000)
-        )
-        await trade_manager_taker.wallet_state_manager.add_pending_transactions(txs1)
-        await full_node.process_transaction_records(records=txs1)
-        await time_out_assert(15, get_trade_and_status, TradeStatus.CONFIRMED, trade_manager_taker, tr1)
+    chia_for_cat = {
+        wallet_maker.id(): 1000,
+        cat_wallet_maker.id(): -4,
+    }
-    @pytest.mark.anyio
-    async def test_aggregated_trade_state(self, wallets_prefarm):
-        (
-            [wallet_node_maker, maker_funds],
-            [wallet_node_taker, taker_funds],
-            full_node,
-        ) = wallets_prefarm
-        wallet_maker = wallet_node_maker.wallet_state_manager.main_wallet
-        xch_to_cat_amount = uint64(100)
+    trade_manager_maker = wallet_node_maker.wallet_state_manager.trade_manager
+    trade_manager_taker = wallet_node_taker.wallet_state_manager.trade_manager
-        async with wallet_node_maker.wallet_state_manager.lock:
-            cat_wallet_maker, _ = await CATWallet.create_new_cat_wallet(
-                wallet_node_maker.wallet_state_manager,
-                wallet_maker,
-                {"identifier": "genesis_by_id"},
-                xch_to_cat_amount,
-                DEFAULT_TX_CONFIG,
-            )
+    success, trade_make, _, error = await trade_manager_maker.create_offer_for_ids(chia_for_cat, DEFAULT_TX_CONFIG)
+    await time_out_assert(10, get_trade_and_status, TradeStatus.PENDING_ACCEPT, trade_manager_maker, trade_make)
+    assert error is None
+    assert success is True
+    assert trade_make is not None
+    peer = wallet_node_taker.get_full_node_peer()
+    offer = Offer.from_bytes(trade_make.offer)
+    [offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
+        [Offer.from_bytes(trade_make.offer)]
+    )
+    tr1, txs1 = await trade_manager_taker.respond_to_offer(offer, peer, DEFAULT_TX_CONFIG, fee=uint64(1000000000000))
+    txs1 = await trade_manager_taker.wallet_state_manager.add_pending_transactions(
+        txs1, additional_signing_responses=signing_response
+    )
+    await full_node.process_transaction_records(records=txs1)
+    await time_out_assert(15, get_trade_and_status, TradeStatus.CONFIRMED, trade_manager_taker, tr1)
-            tx_records: List[TransactionRecord] = await wallet_node_maker.wallet_state_manager.tx_store.get_not_sent()
-        await full_node.process_transaction_records(records=tx_records)
+@pytest.mark.parametrize("trusted", [True, False])
+@pytest.mark.anyio
+async def test_aggregated_trade_state(wallets_prefarm):
+    (
+        [wallet_node_maker, maker_funds],
+        [wallet_node_taker, taker_funds],
+        full_node,
+    ) = wallets_prefarm
+    wallet_maker = wallet_node_maker.wallet_state_manager.main_wallet
+    xch_to_cat_amount = uint64(100)
+    async with wallet_node_maker.wallet_state_manager.lock:
+        cat_wallet_maker, tx_records = await CATWallet.create_new_cat_wallet(
+            wallet_node_maker.wallet_state_manager,
+            wallet_maker,
+            {"identifier": "genesis_by_id"},
+            xch_to_cat_amount,
+            DEFAULT_TX_CONFIG,
+        )
-        await time_out_assert(15, cat_wallet_maker.get_confirmed_balance, xch_to_cat_amount)
-        await time_out_assert(15, cat_wallet_maker.get_unconfirmed_balance, xch_to_cat_amount)
-        maker_funds -= xch_to_cat_amount
-        await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds)
+    await full_node.process_transaction_records(records=tx_records)
-        chia_for_cat = {
-            wallet_maker.id(): 2,
-            cat_wallet_maker.id(): -2,
-        }
-        cat_for_chia = {
-            wallet_maker.id(): -1,
-            cat_wallet_maker.id(): 1,
-        }
+    await time_out_assert(15, cat_wallet_maker.get_confirmed_balance, xch_to_cat_amount)
+    await time_out_assert(15, cat_wallet_maker.get_unconfirmed_balance, xch_to_cat_amount)
+    maker_funds -= xch_to_cat_amount
+    await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds)
-        trade_manager_maker = wallet_node_maker.wallet_state_manager.trade_manager
-        trade_manager_taker = wallet_node_taker.wallet_state_manager.trade_manager
+    chia_for_cat = {
+        wallet_maker.id(): 2,
+        cat_wallet_maker.id(): -2,
+    }
+    cat_for_chia = {
+        wallet_maker.id(): -1,
+        cat_wallet_maker.id(): 1,
+    }
-        async def get_trade_and_status(trade_manager, trade) -> TradeStatus:
-            trade_rec = await trade_manager.get_trade_by_id(trade.trade_id)
-            if trade_rec:
-                return TradeStatus(trade_rec.status)
-            raise ValueError("Couldn't find the trade record")  # pragma: no cover
+    trade_manager_maker = wallet_node_maker.wallet_state_manager.trade_manager
+    trade_manager_taker = wallet_node_taker.wallet_state_manager.trade_manager
-        success, trade_make_1, _, error = await trade_manager_maker.create_offer_for_ids(
-            chia_for_cat, DEFAULT_TX_CONFIG
-        )
-        await time_out_assert(10, get_trade_and_status, TradeStatus.PENDING_ACCEPT, trade_manager_maker, trade_make_1)
-        assert error is None
-        assert success is True
-        assert trade_make_1 is not None
-        success, trade_make_2, _, error = await trade_manager_maker.create_offer_for_ids(
-            cat_for_chia, DEFAULT_TX_CONFIG
-        )
-        await time_out_assert(10, get_trade_and_status, TradeStatus.PENDING_ACCEPT, trade_manager_maker, trade_make_2)
-        assert error is None
-        assert success is True
-        assert trade_make_2 is not None
+    success, trade_make_1, _, error = await trade_manager_maker.create_offer_for_ids(chia_for_cat, DEFAULT_TX_CONFIG)
+    await time_out_assert(10, get_trade_and_status, TradeStatus.PENDING_ACCEPT, trade_manager_maker, trade_make_1)
+    assert error is None
+    assert success is True
+    assert trade_make_1 is not None
+    success, trade_make_2, _, error = await trade_manager_maker.create_offer_for_ids(cat_for_chia, DEFAULT_TX_CONFIG)
+    await time_out_assert(10, get_trade_and_status, TradeStatus.PENDING_ACCEPT, trade_manager_maker, trade_make_2)
+    assert error is None
+    assert success is True
+    assert trade_make_2 is not None
-        agg_offer = Offer.aggregate([Offer.from_bytes(trade_make_1.offer), Offer.from_bytes(trade_make_2.offer)])
+    [offer_1], signing_response_1 = await wallet_node_maker.wallet_state_manager.sign_offers(
+        [Offer.from_bytes(trade_make_1.offer)]
+    )
+    [offer_2], signing_response_2 = await wallet_node_maker.wallet_state_manager.sign_offers(
+        [Offer.from_bytes(trade_make_2.offer)]
+    )
+    agg_offer = Offer.aggregate([offer_1, offer_2])
-        peer = wallet_node_taker.get_full_node_peer()
-        trade_take, tx_records = await trade_manager_taker.respond_to_offer(
-            agg_offer,
-            peer,
-            DEFAULT_TX_CONFIG,
-        )
-        assert trade_take is not None
-        assert tx_records is not None
+    peer = wallet_node_taker.get_full_node_peer()
+    trade_take, tx_records = await trade_manager_taker.respond_to_offer(
+        agg_offer,
+        peer,
+        DEFAULT_TX_CONFIG,
+    )
+    assert trade_take is not None
+    assert tx_records is not None
-        await trade_manager_taker.wallet_state_manager.add_pending_transactions(tx_records)
-        await full_node.process_transaction_records(records=tx_records)
-        await full_node.wait_for_wallets_synced(wallet_nodes=[wallet_node_maker, wallet_node_taker], timeout=60)
+    tx_records = await trade_manager_taker.wallet_state_manager.add_pending_transactions(
+        tx_records,
+        additional_signing_responses=[*signing_response_1, *signing_response_2],
+    )
+    await full_node.process_transaction_records(records=tx_records)
+    await full_node.wait_for_wallets_synced(wallet_nodes=[wallet_node_maker, wallet_node_taker], timeout=60)
-        await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds + 1)
-        await time_out_assert(15, wallet_maker.get_unconfirmed_balance, maker_funds + 1)
-        await time_out_assert(15, cat_wallet_maker.get_confirmed_balance, xch_to_cat_amount - 1)
-        await time_out_assert(15, cat_wallet_maker.get_unconfirmed_balance, xch_to_cat_amount - 1)
+    await time_out_assert(15, wallet_maker.get_confirmed_balance, maker_funds + 1)
+    await time_out_assert(15, wallet_maker.get_unconfirmed_balance, maker_funds + 1)
+    await time_out_assert(15, cat_wallet_maker.get_confirmed_balance, xch_to_cat_amount - 1)
+    await time_out_assert(15, cat_wallet_maker.get_unconfirmed_balance, xch_to_cat_amount - 1)

tests/wallet/dao_wallet/test_dao_clvm.py CHANGED Viewed

         @@@ -555,7 -549,7 +555,7 @@@ def test_validator() -> None
         1200,
     )
     full_proposal = SINGLETON_MOD.curry(proposal_struct, proposal)
-    proposal_amt = 10
+    proposal_amt = uint64(10)
     proposal_coin_id = Coin(parent_id, full_proposal.get_tree_hash(), proposal_amt).name()
     solution = Program.to(
         [
         @@@ -696,7 -678,7 +696,7 @@@ def test_merge_p2_singleton() -> None
     # Merge Spend (not output creator)
     output_parent_id = Program.to("output_parent").get_tree_hash()
-    output_coin_amount = 100
+    output_coin_amount = uint64(100)
     aggregator_sol = Program.to([my_id, my_puzhash, 300, 0, [output_parent_id, output_coin_amount]])
     merge_p2_singleton_sol = Program.to([aggregator_sol, 0, 0, 0, 0])
     conds = conditions_dict_for_solution(p2_singleton, merge_p2_singleton_sol, INFINITE_COST)
         @@@ -706,7 -688,7 +706,7 @@@
     # Merge Spend (output creator)
     fake_parent_id = Program.to("fake_parent").get_tree_hash()
-    merged_coin_id = Coin(fake_parent_id, my_puzhash, 200).name()
+    merged_coin_id = Coin(fake_parent_id, my_puzhash, uint64(200)).name()
     merge_sol = Program.to([[my_id, my_puzhash, 100, [[fake_parent_id, my_puzhash, 200]], 0]])
     conds = conditions_dict_for_solution(p2_singleton, merge_sol, INFINITE_COST)
     assert len(conds) == 7
         @@@ -719,12 -701,9 +719,12 @@@
         Program.to("fake_parent_2").get_tree_hash(),
         Program.to("fake_parent_3").get_tree_hash(),
     ]
-    amounts = [1000, 2000, 3000]
-    parent_puzhash_amounts = [[pid, my_puzhash, amt] for pid, amt in zip(parent_ids, amounts)]
-    merge_coin_ids = [Coin(pid, ph, amt).name() for pid, ph, amt in parent_puzhash_amounts]
+    amounts = [uint64(1000), uint64(2000), uint64(3000)]
+    parent_puzhash_amounts = []
+    merge_coin_ids: List[bytes32] = []
+    for pid, amt in zip(parent_ids, amounts):
+        parent_puzhash_amounts.append([pid, my_puzhash, amt])
+        merge_coin_ids.append(Coin(pid, my_puzhash, amt).name())
     output_parent_amount = [output_parent_id, output_coin_amount]
     output_coin_id = Coin(output_parent_id, my_puzhash, output_coin_amount).name()
         @@@ -843,7 -820,7 +843,7 @@@ def test_treasury() -> None
     assert len(conds.as_python()) == 3
     # Proposal Spend
-    proposal_amt = 10
+    proposal_amt = uint64(10)
     proposal_coin_id = Coin(parent_id, full_proposal.get_tree_hash(), proposal_amt).name()
     solution = Program.to(
         [
         @@@ -1090,7 -1061,7 +1090,7 @@@ def test_proposal_lifecycle() -> None
     )
     full_proposal: Program = SINGLETON_MOD.curry(proposal_singleton_struct, proposal)
     full_proposal_puzhash: bytes32 = full_proposal.get_tree_hash()
-    proposal_amt = 11
+    proposal_amt = uint64(11)
     proposal_coin_id = Coin(parent_id, full_proposal_puzhash, proposal_amt).name()
     treasury_solution: Program = Program.to(

tests/wallet/did_wallet/test_did.py CHANGED Viewed

         @@@ -540,6 -543,6 +540,7 @@@ class TestDIDWallet
         spend_bundle = spend_bundle_list[0].spend_bundle
         await time_out_assert_not_none(5, full_node_api.full_node.mempool_manager.get_spendbundle, spend_bundle.name())
         await full_node_api.farm_blocks_to_wallet(1, wallet2)
+        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
         await time_out_assert(15, did_wallet.get_confirmed_balance, 101)
         await time_out_assert(15, did_wallet.get_unconfirmed_balance, 101)
         @@@ -1048,6 -1060,6 +1049,11 @@@
         puzhash = did_wallet_1.did_info.current_inner.get_tree_hash()
         parent_num = get_parent_num(did_wallet_1)
+        bad_metadata = {"Twitter": {"url": "http://www.twitter.com"}}
+        with pytest.raises(ValueError) as e:
+            await did_wallet_1.update_metadata(bad_metadata)
+        assert e.match("Metadata key value pairs must be strings.")
         metadata = {}
         metadata["Twitter"] = "http://www.twitter.com"
         await did_wallet_1.update_metadata(metadata)

tests/wallet/nft_wallet/test_ownership_outer_puzzle.py CHANGED Viewed

         @@@ -21,7 -21,7 +21,7 @@@ def test_ownership_outer_puzzle() -> No
     # (mod (current_owner conditions solution)
     #     (list current_owner () conditions)
     # )
-    transfer_program = assemble(  # type: ignore
+    transfer_program = assemble(
         """
         (c 2 (c () (c 5 ())))
         """

tests/wallet/rpc/test_dl_wallet_rpc.py CHANGED Viewed

         @@@ -6,12 -6,13 +6,13 @@@ import loggin
 import pytest
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
+from chia.data_layer.data_layer_util import DLProof, HashOnlyProof, ProofLayer, StoreProofsHashes
 from chia.data_layer.data_layer_wallet import Mirror
 from chia.rpc.wallet_rpc_client import WalletRpcClient
-from chia.simulator.setup_nodes import SimulatorsAndWalletsServices
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.peer_info import PeerInfo
-from chia.util.ints import uint32, uint64
+from chia.util.ints import uint8, uint32, uint64
 from chia.wallet.db_wallet.db_wallet_puzzles import create_mirror_puzzle
 from tests.conftest import ConsensusMode
 from tests.util.rpc import validate_get_routes
         @@@ -222,3 -222,3 +223,57 @@@ class TestWalletRpc
             client_2.close()
             await client.await_closed()
             await client_2.await_closed()
+    @pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN, ConsensusMode.HARD_FORK_2_0], reason="save time")
+    @pytest.mark.parametrize("trusted", [True, False])
+    @pytest.mark.anyio
+    async def test_wallet_dl_verify_proof(
+        self, one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices, trusted: bool, self_hostname: str
+    ) -> None:
+        [full_node_service], [wallet_service], bt = one_wallet_and_one_simulator_services
+        full_node_api = full_node_service._api
+        full_node_server = full_node_api.full_node.server
+        wallet_node = wallet_service._node
+        # Create fake proof
+        # Specifically
+        fakeproof = HashOnlyProof.from_key_value(
+            key=b"key",
+            value=b"value",
+            node_hash=bytes32([1] * 32),
+            layers=[
+                ProofLayer(
+                    other_hash_side=uint8(0),
+                    other_hash=bytes32([1] * 32),
+                    combined_hash=bytes32([1] * 32),
+                ),
+            ],
+        )
+        fake_coin_id = bytes32([5] * 32)
+        fake_gpr = DLProof(
+            store_proofs=StoreProofsHashes(store_id=bytes32([1] * 32), proofs=[fakeproof]),
+            coin_id=fake_coin_id,
+            inner_puzzle_hash=bytes32([1] * 32),
+        )
+        if trusted:
+            wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
+        else:
+            wallet_node.config["trusted_peers"] = {}
+        assert wallet_service.rpc_server is not None
+        client = await WalletRpcClient.create(
+            self_hostname,
+            wallet_service.rpc_server.listen_port,
+            wallet_service.root_path,
+            wallet_service.config,
+        )
+        with pytest.raises(ValueError, match="No peer connected"):
+            await wallet_service.rpc_server.rpc_api.dl_verify_proof(fake_gpr.to_json_dict())
+        await wallet_node.server.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+        await validate_get_routes(client, wallet_service.rpc_server.rpc_api)
+        with pytest.raises(ValueError, match=f"Invalid Proof: No DL singleton found at coin id: {fake_coin_id}"):
+            await client.dl_verify_proof(fake_gpr)

tests/wallet/rpc/test_wallet_rpc.py CHANGED Viewed

         @@@ -1641,6 -1592,6 +1641,45 @@@ async def test_nft_endpoints(wallet_rpc
     }
+async def _check_delete_key(
+    client: WalletRpcClient, wallet_node: WalletNode, farmer_fp: int, pool_fp: int, observer: bool = False
+) -> None:
+    # Add in reward addresses into farmer and pool for testing delete key checks
+    # set farmer to first private key
+    create_sk = master_sk_to_wallet_sk_unhardened if observer else master_sk_to_wallet_sk
+    sk = await wallet_node.get_key_for_fingerprint(farmer_fp)
+    assert sk is not None
+    farmer_ph = create_puzzlehash_for_pk(create_sk(sk, uint32(0)).get_g1())
+    sk = await wallet_node.get_key_for_fingerprint(pool_fp)
+    assert sk is not None
+    pool_ph = create_puzzlehash_for_pk(create_sk(sk, uint32(0)).get_g1())
+    with lock_and_load_config(wallet_node.root_path, "config.yaml") as test_config:
+        test_config["farmer"]["xch_target_address"] = encode_puzzle_hash(farmer_ph, "txch")
+        test_config["pool"]["xch_target_address"] = encode_puzzle_hash(pool_ph, "txch")
+        save_config(wallet_node.root_path, "config.yaml", test_config)
+    # Check farmer_fp key
+    sk_dict = await client.check_delete_key(farmer_fp)
+    assert sk_dict["fingerprint"] == farmer_fp
+    assert sk_dict["used_for_farmer_rewards"] is True
+    assert sk_dict["used_for_pool_rewards"] is False
+    # Check pool_fp key
+    sk_dict = await client.check_delete_key(pool_fp)
+    assert sk_dict["fingerprint"] == pool_fp
+    assert sk_dict["used_for_farmer_rewards"] is False
+    assert sk_dict["used_for_pool_rewards"] is True
+    # Check unknown key
+    sk_dict = await client.check_delete_key(123456, 10)
+    assert sk_dict["fingerprint"] == 123456
+    assert sk_dict["used_for_farmer_rewards"] is False
+    assert sk_dict["used_for_pool_rewards"] is False
 @pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN, ConsensusMode.HARD_FORK_2_0], reason="save time")
 @pytest.mark.anyio
 async def test_key_and_address_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
         @@@ -1689,67 -1640,67 +1728,32 @@@
     sk_dict = await client.get_private_key(pks[1])
     assert sk_dict["fingerprint"] == pks[1]
-    # Add in reward addresses into farmer and pool for testing delete key checks
-    # set farmer to first private key
-    sk = await wallet_node.get_key_for_fingerprint(pks[0])
-    assert sk is not None
-    test_ph = create_puzzlehash_for_pk(master_sk_to_wallet_sk(sk, uint32(0)).get_g1())
+    # test hardened keys
+    await _check_delete_key(client=client, wallet_node=wallet_node, farmer_fp=pks[0], pool_fp=pks[1], observer=False)
+    # test observer keys
+    await _check_delete_key(client=client, wallet_node=wallet_node, farmer_fp=pks[0], pool_fp=pks[1], observer=True)
+    # set farmer to empty string
     with lock_and_load_config(wallet_node.root_path, "config.yaml") as test_config:
-        test_config["farmer"]["xch_target_address"] = encode_puzzle_hash(test_ph, "txch")
-        # set pool to second private key
-        sk = await wallet_node.get_key_for_fingerprint(pks[1])
-        assert sk is not None
-        test_ph = create_puzzlehash_for_pk(master_sk_to_wallet_sk(sk, uint32(0)).get_g1())
-        test_config["pool"]["xch_target_address"] = encode_puzzle_hash(test_ph, "txch")
+        test_config["farmer"]["xch_target_address"] = ""
         save_config(wallet_node.root_path, "config.yaml", test_config)
-    # Check first key
-    sk_dict = await client.check_delete_key(pks[0])
-    assert sk_dict["fingerprint"] == pks[0]
-    assert sk_dict["used_for_farmer_rewards"] is True
-    assert sk_dict["used_for_pool_rewards"] is False
-    # Check second key
+    # Check key
     sk_dict = await client.check_delete_key(pks[1])
     assert sk_dict["fingerprint"] == pks[1]
     assert sk_dict["used_for_farmer_rewards"] is False
     assert sk_dict["used_for_pool_rewards"] is True
-    # Check unknown key
-    sk_dict = await client.check_delete_key(123456, 10)
-    assert sk_dict["fingerprint"] == 123456
-    assert sk_dict["used_for_farmer_rewards"] is False
-    assert sk_dict["used_for_pool_rewards"] is False
-    # Add in observer reward addresses into farmer and pool for testing delete key checks
-    # set farmer to first private key
-    sk = await wallet_node.get_key_for_fingerprint(pks[0])
-    assert sk is not None
-    test_ph = create_puzzlehash_for_pk(master_sk_to_wallet_sk_unhardened(sk, uint32(0)).get_g1())
+    # set farmer and pool to empty string
     with lock_and_load_config(wallet_node.root_path, "config.yaml") as test_config:
-        test_config["farmer"]["xch_target_address"] = encode_puzzle_hash(test_ph, "txch")
-        # set pool to second private key
-        sk = await wallet_node.get_key_for_fingerprint(pks[1])
-        assert sk is not None
-        test_ph = create_puzzlehash_for_pk(master_sk_to_wallet_sk_unhardened(sk, uint32(0)).get_g1())
-        test_config["pool"]["xch_target_address"] = encode_puzzle_hash(test_ph, "txch")
+        test_config["farmer"]["xch_target_address"] = ""
+        test_config["pool"]["xch_target_address"] = ""
         save_config(wallet_node.root_path, "config.yaml", test_config)
-    # Check first key
+    # Check key
     sk_dict = await client.check_delete_key(pks[0])
     assert sk_dict["fingerprint"] == pks[0]
-    assert sk_dict["used_for_farmer_rewards"] is True
-    assert sk_dict["used_for_pool_rewards"] is False
-    # Check second key
-    sk_dict = await client.check_delete_key(pks[1])
-    assert sk_dict["fingerprint"] == pks[1]
-    assert sk_dict["used_for_farmer_rewards"] is False
-    assert sk_dict["used_for_pool_rewards"] is True
-    # Check unknown key
-    sk_dict = await client.check_delete_key(123456, 10)
-    assert sk_dict["fingerprint"] == 123456
     assert sk_dict["used_for_farmer_rewards"] is False
     assert sk_dict["used_for_pool_rewards"] is False

tests/wallet/simple_sync/test_simple_sync_protocol.py CHANGED Viewed

         @@@ -40,595 -50,486 +40,595 @@@ async def get_all_messages_in_queue(que
     return all_messages
-class TestSimpleSyncProtocol:
-    @pytest.mark.anyio
-    async def test_subscribe_for_ph(self, simulator_and_wallet, self_hostname):
-        num_blocks = 4
-        full_nodes, wallets, _ = simulator_and_wallet
-        full_node_api = full_nodes[0]
-        wallet_node, server_2 = wallets[0]
-        fn_server = full_node_api.full_node.server
-        wsm: WalletStateManager = wallet_node.wallet_state_manager
-        await server_2.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
-        incoming_queue, peer_id = await add_dummy_connection(fn_server, self_hostname, 12312, NodeType.WALLET)
-        zero_ph = 32 * b"\0"
-        junk_ph = 32 * b"\a"
-        fake_wallet_peer = fn_server.all_connections[peer_id]
-        msg = wallet_protocol.RegisterForPhUpdates([zero_ph], 0)
-        msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
-        assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
-        data_response: RespondToPhUpdates = RespondToCoinUpdates.from_bytes(msg_response.data)
-        assert data_response.coin_states == []
-        # Farm few more with reward
-        for i in range(0, num_blocks):
-            if i == num_blocks - 1:
-                await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
-                await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(junk_ph))
-            else:
-                await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
-        msg = wallet_protocol.RegisterForPhUpdates([zero_ph], 0)
-        msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
-        assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
-        data_response: RespondToPhUpdates = RespondToCoinUpdates.from_bytes(msg_response.data)
-        # we have already subscribed to this puzzle hash, it will be ignored
-        # we still receive the updates (see below)
-        assert data_response.coin_states == []
-        # Farm more rewards to check the incoming queue for the updates
-        for i in range(0, num_blocks):
-            if i == num_blocks - 1:
-                await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
-                await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(junk_ph))
-            else:
-                await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
-        all_messages = await get_all_messages_in_queue(incoming_queue)
-        zero_coin = await full_node_api.full_node.coin_store.get_coin_states_by_puzzle_hashes(True, {zero_ph})
-        all_zero_coin = set(zero_coin)
-        notified_zero_coins = set()
-        for message in all_messages:
-            if message.type == ProtocolMessageTypes.coin_state_update.value:
-                data_response: CoinStateUpdate = CoinStateUpdate.from_bytes(message.data)
-                for coin_state in data_response.items:
-                    notified_zero_coins.add(coin_state)
-                assert len(data_response.items) == 2  # 2 per height farmer / pool reward
-        assert all_zero_coin == notified_zero_coins
-        # Test subscribing to more coins
-        one_ph = 32 * b"\1"
-        msg = wallet_protocol.RegisterForPhUpdates([one_ph], 0)
-        msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
-        peak = full_node_api.full_node.blockchain.get_peak()
-        for i in range(0, num_blocks):
-            if i == num_blocks - 1:
-                await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
-                await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(junk_ph))
-            else:
-                await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
-        for i in range(0, num_blocks):
-            if i == num_blocks - 1:
-                await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(one_ph))
-                await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(junk_ph))
-            else:
-                await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(one_ph))
-        zero_coins = await full_node_api.full_node.coin_store.get_coin_states_by_puzzle_hashes(
-            True, {zero_ph}, peak.height + 1
-        )
-        one_coins = await full_node_api.full_node.coin_store.get_coin_states_by_puzzle_hashes(True, {one_ph})
-        all_coins = set(zero_coins)
-        all_coins.update(one_coins)
-        all_messages = await get_all_messages_in_queue(incoming_queue)
-        notified_all_coins = set()
-        for message in all_messages:
-            if message.type == ProtocolMessageTypes.coin_state_update.value:
-                data_response: CoinStateUpdate = CoinStateUpdate.from_bytes(message.data)
-                for coin_state in data_response.items:
-                    notified_all_coins.add(coin_state)
-                assert len(data_response.items) == 2  # 2 per height farmer / pool reward
-        assert all_coins == notified_all_coins
+@pytest.mark.anyio
+async def test_subscribe_for_ph(simulator_and_wallet: OldSimulatorsAndWallets, self_hostname: str) -> None:
+    num_blocks = 4
+    full_nodes, wallets, _ = simulator_and_wallet
+    full_node_api = full_nodes[0]
+    wallet_node, server_2 = wallets[0]
+    fn_server = full_node_api.full_node.server
-        wsm: WalletStateManager = wallet_node.wallet_state_manager
-        wallet: Wallet = wsm.wallets[1]
-        puzzle_hash = await wallet.get_new_puzzlehash()
+    await server_2.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
+    incoming_queue, peer_id = await add_dummy_connection(fn_server, self_hostname, 12312, NodeType.WALLET)
-        for i in range(0, num_blocks):
-            if i == num_blocks - 1:
-                await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(puzzle_hash))
-                await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(junk_ph))
-            else:
-                await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(puzzle_hash))
+    junk_ph = bytes32(32 * b"\a")
+    fake_wallet_peer = fn_server.all_connections[peer_id]
+    msg = wallet_protocol.RegisterForPhUpdates([zero_ph], uint32(0))
+    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
-        funds = sum(
-            [
-                calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i))
-                for i in range(1, num_blocks + 1)
-            ]
-        )
-        fn_amount = sum(
-            cr.coin.amount
-            for cr in await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(False, puzzle_hash)
-        )
+    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
+    data_response = RespondToCoinUpdates.from_bytes(msg_response.data)
+    assert data_response.coin_states == []
-        await time_out_assert(20, wallet.get_confirmed_balance, funds)
-        assert funds == fn_amount
+    # Farm few more with reward
+    for i in range(num_blocks):
+        if i == num_blocks - 1:
+            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
+            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(junk_ph))
+        else:
+            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
-        msg_1 = wallet_protocol.RegisterForPhUpdates([puzzle_hash], 0)
-        msg_response_1 = await full_node_api.register_interest_in_puzzle_hash(msg_1, fake_wallet_peer)
-        assert msg_response_1.type == ProtocolMessageTypes.respond_to_ph_update.value
-        data_response_1: RespondToPhUpdates = RespondToCoinUpdates.from_bytes(msg_response_1.data)
-        assert len(data_response_1.coin_states) == 2 * num_blocks  # 2 per height farmer / pool reward
+    msg = wallet_protocol.RegisterForPhUpdates([zero_ph], uint32(0))
+    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
+    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
+    data_response = RespondToCoinUpdates.from_bytes(msg_response.data)
+    # we have already subscribed to this puzzle hash, it will be ignored
+    # we still receive the updates (see below)
+    assert data_response.coin_states == []
+    # Farm more rewards to check the incoming queue for the updates
+    for i in range(num_blocks):
+        if i == num_blocks - 1:
+            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
+            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(junk_ph))
+        else:
+            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
-        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
+    all_messages = await get_all_messages_in_queue(incoming_queue)
-        [tx_record] = await wallet.generate_signed_transaction(uint64(10), puzzle_hash, DEFAULT_TX_CONFIG, uint64(0))
-        assert len(tx_record.spend_bundle.removals()) == 1
-        spent_coin = tx_record.spend_bundle.removals()[0]
-        assert spent_coin.puzzle_hash == puzzle_hash
+    zero_coin = await full_node_api.full_node.coin_store.get_coin_states_by_puzzle_hashes(True, {zero_ph})
+    all_zero_coin = set(zero_coin)
+    notified_zero_coins = set()
-        await wallet_node.wallet_state_manager.add_pending_transactions([tx_record])
+    for message in all_messages:
+        if message.type == ProtocolMessageTypes.coin_state_update.value:
+            coin_state_update = CoinStateUpdate.from_bytes(message.data)
+            assert len(coin_state_update.items) == 2  # 2 per height farmer / pool reward
+            for coin_state in coin_state_update.items:
+                notified_zero_coins.add(coin_state)
-        await full_node_api.process_transaction_records(records=[tx_record])
+    assert all_zero_coin == notified_zero_coins
-        # Let's make sure the wallet can handle a non ephemeral launcher
-        from chia.wallet.puzzles.singleton_top_layer import SINGLETON_LAUNCHER_HASH
+    # Test subscribing to more coins
+    one_ph = bytes32(32 * b"\1")
+    msg = wallet_protocol.RegisterForPhUpdates([one_ph], uint32(0))
+    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
+    peak = full_node_api.full_node.blockchain.get_peak()
-        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
+    for i in range(num_blocks):
+        if i == num_blocks - 1:
+            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
+            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(junk_ph))
+        else:
+            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
-        [tx_record] = await wallet.generate_signed_transaction(
-            uint64(10), SINGLETON_LAUNCHER_HASH, DEFAULT_TX_CONFIG, uint64(0)
-        )
-        await wallet_node.wallet_state_manager.add_pending_transactions([tx_record])
+    for i in range(num_blocks):
+        if i == num_blocks - 1:
+            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(one_ph))
+            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(junk_ph))
+        else:
+            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(one_ph))
-        await full_node_api.process_transaction_records(records=[tx_record])
+    assert peak is not None
+    zero_coins = await full_node_api.full_node.coin_store.get_coin_states_by_puzzle_hashes(
+        True, {zero_ph}, uint32(peak.height + 1)
+    )
+    one_coins = await full_node_api.full_node.coin_store.get_coin_states_by_puzzle_hashes(True, {one_ph})
-        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
+    all_coins = set(zero_coins)
+    all_coins.update(one_coins)
-        # Send a transaction to make sure the wallet is still running
-        [tx_record] = await wallet.generate_signed_transaction(uint64(10), junk_ph, DEFAULT_TX_CONFIG, uint64(0))
-        await wallet_node.wallet_state_manager.add_pending_transactions([tx_record])
+    all_messages = await get_all_messages_in_queue(incoming_queue)
-        await full_node_api.process_transaction_records(records=[tx_record])
+    notified_all_coins = set()
-        all_messages = await get_all_messages_in_queue(incoming_queue)
+    for message in all_messages:
+        if message.type == ProtocolMessageTypes.coin_state_update.value:
+            coin_state_update = CoinStateUpdate.from_bytes(message.data)
+            assert len(coin_state_update.items) == 2  # 2 per height farmer / pool reward
+            for coin_state in coin_state_update.items:
+                notified_all_coins.add(coin_state)
-        notified_state = None
+    assert all_coins == notified_all_coins
-        for message in all_messages:
-            if message.type == ProtocolMessageTypes.coin_state_update.value:
-                data_response: CoinStateUpdate = CoinStateUpdate.from_bytes(message.data)
-                for coin_state in data_response.items:
-                    if coin_state.coin.name() == spent_coin.name():
-                        notified_state = coin_state
+    wallet = wallet_node.wallet_state_manager.wallets[uint32(1)]
+    assert isinstance(wallet, Wallet)
+    puzzle_hash = await wallet.get_new_puzzlehash()
-        assert notified_state is not None
-        assert notified_state.coin == spent_coin
-        assert notified_state.spent_height is not None
-    @pytest.mark.anyio
-    async def test_subscribe_for_coin_id(self, simulator_and_wallet, self_hostname):
-        num_blocks = 4
-        full_nodes, wallets, _ = simulator_and_wallet
-        full_node_api = full_nodes[0]
-        wallet_node, server_2 = wallets[0]
-        fn_server = full_node_api.full_node.server
-        wsm: WalletStateManager = wallet_node.wallet_state_manager
-        standard_wallet: Wallet = wsm.wallets[1]
-        puzzle_hash = await standard_wallet.get_new_puzzlehash()
-        await server_2.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
-        incoming_queue, peer_id = await add_dummy_connection(fn_server, self_hostname, 12312, NodeType.WALLET)
-        fake_wallet_peer = fn_server.all_connections[peer_id]
-        # Farm to create a coin that we'll track
-        for i in range(0, num_blocks):
+    for i in range(num_blocks):
+        if i == num_blocks - 1:
+            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(puzzle_hash))
+            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(junk_ph))
+        else:
             await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(puzzle_hash))
-        funds = sum(
-            [calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks)]
-        )
+    funds = sum(
+        [calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks + 1)]
+    )
+    fn_amount = sum(
+        cr.coin.amount
+        for cr in await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(False, puzzle_hash)
+    )
-        await time_out_assert(20, standard_wallet.get_confirmed_balance, funds)
+    await time_out_assert(20, wallet.get_confirmed_balance, funds)
+    assert funds == fn_amount
-        my_coins: List[CoinRecord] = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(
-            True, puzzle_hash
-        )
-        coin_to_spend = my_coins[0].coin
+    msg_1 = wallet_protocol.RegisterForPhUpdates([puzzle_hash], uint32(0))
+    msg_response_1 = await full_node_api.register_interest_in_puzzle_hash(msg_1, fake_wallet_peer)
+    assert msg_response_1.type == ProtocolMessageTypes.respond_to_ph_update.value
+    data_response_1 = RespondToCoinUpdates.from_bytes(msg_response_1.data)
+    assert len(data_response_1.coin_states) == 2 * num_blocks  # 2 per height farmer / pool reward
-        msg = wallet_protocol.RegisterForCoinUpdates([coin_to_spend.name()], 0)
-        msg_response = await full_node_api.register_interest_in_coin(msg, fake_wallet_peer)
-        assert msg_response is not None
-        assert msg_response.type == ProtocolMessageTypes.respond_to_coin_update.value
-        data_response: RespondToCoinUpdates = RespondToCoinUpdates.from_bytes(msg_response.data)
-        assert data_response.coin_states[0].coin == coin_to_spend
+    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
-        coins = set()
-        coins.add(coin_to_spend)
-        [tx_record] = await standard_wallet.generate_signed_transaction(
-            uint64(10), puzzle_hash, DEFAULT_TX_CONFIG, uint64(0), coins=coins
-        )
-        await standard_wallet.wallet_state_manager.add_pending_transactions([tx_record])
+    [tx_record] = await wallet.generate_signed_transaction(uint64(10), puzzle_hash, DEFAULT_TX_CONFIG, uint64(0))
+    assert tx_record.spend_bundle is not None
+    assert len(tx_record.spend_bundle.removals()) == 1
+    spent_coin = tx_record.spend_bundle.removals()[0]
+    assert spent_coin.puzzle_hash == puzzle_hash
-        await full_node_api.process_transaction_records(records=[tx_record])
+    [tx_record] = await wallet.wallet_state_manager.add_pending_transactions([tx_record])
-        all_messages = await get_all_messages_in_queue(incoming_queue)
+    await full_node_api.process_transaction_records(records=[tx_record])
-        notified_coins = set()
-        for message in all_messages:
-            if message.type == ProtocolMessageTypes.coin_state_update.value:
-                data_response: CoinStateUpdate = CoinStateUpdate.from_bytes(message.data)
-                for coin_state in data_response.items:
-                    notified_coins.add(coin_state.coin)
-                    assert coin_state.spent_height is not None
+    # Let's make sure the wallet can handle a non ephemeral launcher
+    from chia.wallet.puzzles.singleton_top_layer import SINGLETON_LAUNCHER_HASH
-        assert notified_coins == coins
+    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
-        # Test getting notification for coin that is about to be created
-        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
+    [tx_record] = await wallet.generate_signed_transaction(
+        uint64(10), SINGLETON_LAUNCHER_HASH, DEFAULT_TX_CONFIG, uint64(0)
+    )
+    [tx_record] = await wallet.wallet_state_manager.add_pending_transactions([tx_record])
-        [tx_record] = await standard_wallet.generate_signed_transaction(
-            uint64(10), puzzle_hash, DEFAULT_TX_CONFIG, uint64(0)
-        )
+    await full_node_api.process_transaction_records(records=[tx_record])
-        tx_record.spend_bundle.additions()
+    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
-        added_target: Optional[Coin] = None
-        for coin in tx_record.spend_bundle.additions():
-            if coin.puzzle_hash == puzzle_hash:
-                added_target = coin
+    # Send a transaction to make sure the wallet is still running
+    [tx_record] = await wallet.generate_signed_transaction(uint64(10), junk_ph, DEFAULT_TX_CONFIG, uint64(0))
+    [tx_record] = await wallet.wallet_state_manager.add_pending_transactions([tx_record])
-        assert added_target is not None
+    await full_node_api.process_transaction_records(records=[tx_record])
-        msg = wallet_protocol.RegisterForCoinUpdates([added_target.name()], 0)
-        msg_response = await full_node_api.register_interest_in_coin(msg, fake_wallet_peer)
-        assert msg_response is not None
-        assert msg_response.type == ProtocolMessageTypes.respond_to_coin_update.value
-        data_response: RespondToCoinUpdates = RespondToCoinUpdates.from_bytes(msg_response.data)
-        assert len(data_response.coin_states) == 0
+    all_messages = await get_all_messages_in_queue(incoming_queue)
-        await standard_wallet.wallet_state_manager.add_pending_transactions([tx_record])
+    notified_state = None
-        await full_node_api.process_transaction_records(records=[tx_record])
+    for message in all_messages:
+        if message.type == ProtocolMessageTypes.coin_state_update.value:
+            coin_state_update = CoinStateUpdate.from_bytes(message.data)
+            for coin_state in coin_state_update.items:
+                if coin_state.coin.name() == spent_coin.name():
+                    notified_state = coin_state
-        all_messages = await get_all_messages_in_queue(incoming_queue)
+    assert notified_state is not None
+    assert notified_state.coin == spent_coin
+    assert notified_state.spent_height is not None
-        notified_state = None
-        for message in all_messages:
-            if message.type == ProtocolMessageTypes.coin_state_update.value:
-                data_response: CoinStateUpdate = CoinStateUpdate.from_bytes(message.data)
-                for coin_state in data_response.items:
-                    if coin_state.coin.name() == added_target.name():
-                        notified_state = coin_state
+@pytest.mark.anyio
+async def test_subscribe_for_coin_id(simulator_and_wallet: OldSimulatorsAndWallets, self_hostname: str) -> None:
+    num_blocks = 4
+    full_nodes, wallets, _ = simulator_and_wallet
+    full_node_api = full_nodes[0]
+    wallet_node, server_2 = wallets[0]
+    fn_server = full_node_api.full_node.server
+    standard_wallet = wallet_node.wallet_state_manager.wallets[uint32(1)]
+    assert isinstance(standard_wallet, Wallet)
+    puzzle_hash = await standard_wallet.get_new_puzzlehash()
-        assert notified_state is not None
-        assert notified_state.coin == added_target
-        assert notified_state.spent_height is None
-    @pytest.mark.anyio
-    async def test_subscribe_for_ph_reorg(self, simulator_and_wallet, self_hostname):
-        num_blocks = 4
-        long_blocks = 20
-        full_nodes, wallets, _ = simulator_and_wallet
-        full_node_api = full_nodes[0]
-        wallet_node, server_2 = wallets[0]
-        fn_server = full_node_api.full_node.server
-        wsm: WalletStateManager = wallet_node.wallet_state_manager
-        standard_wallet: Wallet = wsm.wallets[1]
-        puzzle_hash = await standard_wallet.get_new_puzzlehash()
-        await server_2.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
-        incoming_queue, peer_id = await add_dummy_connection(fn_server, self_hostname, 12312, NodeType.WALLET)
-        fake_wallet_peer = fn_server.all_connections[peer_id]
-        zero_ph = 32 * b"\0"
-        # Farm to create a coin that we'll track
-        for i in range(0, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
+    await server_2.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
+    incoming_queue, peer_id = await add_dummy_connection(fn_server, self_hostname, 12312, NodeType.WALLET)
-        for i in range(0, long_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
+    fake_wallet_peer = fn_server.all_connections[peer_id]
-        msg = wallet_protocol.RegisterForPhUpdates([puzzle_hash], 0)
-        msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
-        assert msg_response is not None
+    # Farm to create a coin that we'll track
+    for _ in range(num_blocks):
         await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(puzzle_hash))
-        for i in range(0, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
+    funds = sum(
+        [calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks)]
+    )
-        expected_height = uint32(long_blocks + 2 * num_blocks + 1)
-        await time_out_assert(20, full_node_api.full_node.blockchain.get_peak_height, expected_height)
+    await time_out_assert(20, standard_wallet.get_confirmed_balance, funds)
-        coin_records = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(True, puzzle_hash)
-        assert len(coin_records) > 0
-        fork_height = expected_height - num_blocks - 5
-        req = ReorgProtocol(fork_height, expected_height + 5, zero_ph, None)
-        await full_node_api.reorg_from_index_to_new_index(req)
+    my_coins = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(True, puzzle_hash)
+    coin_to_spend = my_coins[0].coin
-        coin_records = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(True, puzzle_hash)
-        assert coin_records == []
+    msg = wallet_protocol.RegisterForCoinUpdates([coin_to_spend.name()], uint32(0))
+    msg_response = await full_node_api.register_interest_in_coin(msg, fake_wallet_peer)
+    assert msg_response is not None
+    assert msg_response.type == ProtocolMessageTypes.respond_to_coin_update.value
+    data_response = RespondToCoinUpdates.from_bytes(msg_response.data)
+    assert data_response.coin_states[0].coin == coin_to_spend
-        all_messages = await get_all_messages_in_queue(incoming_queue)
+    coins = set()
+    coins.add(coin_to_spend)
+    [tx_record] = await standard_wallet.generate_signed_transaction(
+        uint64(10), puzzle_hash, DEFAULT_TX_CONFIG, uint64(0), coins=coins
+    )
+    [tx_record] = await standard_wallet.wallet_state_manager.add_pending_transactions([tx_record])
-        coin_update_messages = []
-        for message in all_messages:
-            if message.type == ProtocolMessageTypes.coin_state_update.value:
-                data_response: CoinStateUpdate = CoinStateUpdate.from_bytes(message.data)
-                coin_update_messages.append(data_response)
-        # First state is creation, second one is a reorg
-        assert len(coin_update_messages) == 2
-        first = coin_update_messages[0]
-        assert len(first.items) == 2
-        first_state_coin_1 = first.items[0]
-        assert first_state_coin_1.spent_height is None
-        assert first_state_coin_1.created_height is not None
-        first_state_coin_2 = first.items[1]
-        assert first_state_coin_2.spent_height is None
-        assert first_state_coin_2.created_height is not None
-        second = coin_update_messages[1]
-        assert second.fork_height == fork_height
-        assert len(second.items) == 2
-        second_state_coin_1 = second.items[0]
-        assert second_state_coin_1.spent_height is None
-        assert second_state_coin_1.created_height is None
-        second_state_coin_2 = second.items[1]
-        assert second_state_coin_2.spent_height is None
-        assert second_state_coin_2.created_height is None
-    @pytest.mark.anyio
-    async def test_subscribe_for_coin_id_reorg(self, simulator_and_wallet, self_hostname):
-        num_blocks = 4
-        long_blocks = 20
-        full_nodes, wallets, _ = simulator_and_wallet
-        full_node_api = full_nodes[0]
-        wallet_node, server_2 = wallets[0]
-        fn_server = full_node_api.full_node.server
-        wsm: WalletStateManager = wallet_node.wallet_state_manager
-        standard_wallet: Wallet = wsm.wallets[1]
-        puzzle_hash = await standard_wallet.get_new_puzzlehash()
-        await server_2.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
-        incoming_queue, peer_id = await add_dummy_connection(fn_server, self_hostname, 12312, NodeType.WALLET)
-        fake_wallet_peer = fn_server.all_connections[peer_id]
-        zero_ph = 32 * b"\0"
-        # Farm to create a coin that we'll track
-        for i in range(0, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
+    await full_node_api.process_transaction_records(records=[tx_record])
-        for i in range(0, long_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
+    all_messages = await get_all_messages_in_queue(incoming_queue)
-        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(puzzle_hash))
+    notified_coins = set()
+    for message in all_messages:
+        if message.type == ProtocolMessageTypes.coin_state_update.value:
+            coin_state_update = CoinStateUpdate.from_bytes(message.data)
+            for coin_state in coin_state_update.items:
+                notified_coins.add(coin_state.coin)
+                assert coin_state.spent_height is not None
-        for i in range(0, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
+    assert notified_coins == coins
-        expected_height = uint32(long_blocks + 2 * num_blocks + 1)
-        await time_out_assert(20, full_node_api.full_node.blockchain.get_peak_height, expected_height)
+    # Test getting notification for coin that is about to be created
+    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
-        coin_records = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(True, puzzle_hash)
-        assert len(coin_records) > 0
+    [tx_record] = await standard_wallet.generate_signed_transaction(
+        uint64(10), puzzle_hash, DEFAULT_TX_CONFIG, uint64(0)
+    )
-        for coin_rec in coin_records:
-            msg = wallet_protocol.RegisterForCoinUpdates([coin_rec.name], 0)
-            msg_response = await full_node_api.register_interest_in_coin(msg, fake_wallet_peer)
-            assert msg_response is not None
+    added_target = None
+    assert tx_record.spend_bundle is not None
+    for coin in tx_record.spend_bundle.additions():
+        if coin.puzzle_hash == puzzle_hash:
+            added_target = coin
+    assert added_target is not None
+    msg = wallet_protocol.RegisterForCoinUpdates([added_target.name()], uint32(0))
+    msg_response = await full_node_api.register_interest_in_coin(msg, fake_wallet_peer)
+    assert msg_response is not None
+    assert msg_response.type == ProtocolMessageTypes.respond_to_coin_update.value
+    data_response = RespondToCoinUpdates.from_bytes(msg_response.data)
+    assert len(data_response.coin_states) == 0
+    [tx_record] = await standard_wallet.wallet_state_manager.add_pending_transactions([tx_record])
+    await full_node_api.process_transaction_records(records=[tx_record])
+    all_messages = await get_all_messages_in_queue(incoming_queue)
+    notified_state = None
+    for message in all_messages:
+        if message.type == ProtocolMessageTypes.coin_state_update.value:
+            coin_state_update = CoinStateUpdate.from_bytes(message.data)
+            for coin_state in coin_state_update.items:
+                if coin_state.coin.name() == added_target.name():
+                    notified_state = coin_state
+    assert notified_state is not None
+    assert notified_state.coin == added_target
+    assert notified_state.spent_height is None
+@pytest.mark.anyio
+async def test_subscribe_for_ph_reorg(simulator_and_wallet: OldSimulatorsAndWallets, self_hostname: str) -> None:
+    num_blocks = 4
+    long_blocks = 20
+    full_nodes, wallets, _ = simulator_and_wallet
+    full_node_api = full_nodes[0]
+    wallet_node, server_2 = wallets[0]
+    fn_server = full_node_api.full_node.server
+    standard_wallet = wallet_node.wallet_state_manager.wallets[uint32(1)]
+    assert isinstance(standard_wallet, Wallet)
+    puzzle_hash = await standard_wallet.get_new_puzzlehash()
+    await server_2.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
+    incoming_queue, peer_id = await add_dummy_connection(fn_server, self_hostname, 12312, NodeType.WALLET)
+    fake_wallet_peer = fn_server.all_connections[peer_id]
+    # Farm to create a coin that we'll track
+    for _ in range(num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
+    for _ in range(long_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
+    msg = wallet_protocol.RegisterForPhUpdates([puzzle_hash], uint32(0))
+    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
+    assert msg_response is not None
+    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(puzzle_hash))
+    for _ in range(num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
+    expected_height = uint32(long_blocks + 2 * num_blocks + 1)
+    await time_out_assert(20, full_node_api.full_node.blockchain.get_peak_height, expected_height)
+    coin_records = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(True, puzzle_hash)
+    assert len(coin_records) > 0
+    fork_height = uint32(expected_height - num_blocks - 5)
+    req = ReorgProtocol(fork_height, uint32(expected_height + 5), zero_ph, None)
+    await full_node_api.reorg_from_index_to_new_index(req)
+    coin_records = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(True, puzzle_hash)
+    assert coin_records == []
-        fork_height = expected_height - num_blocks - 5
-        req = ReorgProtocol(fork_height, expected_height + 5, zero_ph, None)
-        await full_node_api.reorg_from_index_to_new_index(req)
+    all_messages = await get_all_messages_in_queue(incoming_queue)
-        coin_records = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(True, puzzle_hash)
-        assert coin_records == []
+    coin_update_messages: List[CoinStateUpdate] = []
+    for message in all_messages:
+        if message.type == ProtocolMessageTypes.coin_state_update.value:
+            coin_state_update = CoinStateUpdate.from_bytes(message.data)
+            coin_update_messages.append(coin_state_update)
+    # First state is creation, second one is a reorg
+    assert len(coin_update_messages) == 2
+    first = coin_update_messages[0]
-        all_messages = await get_all_messages_in_queue(incoming_queue)
+    assert len(first.items) == 2
+    first_state_coin_1 = first.items[0]
+    assert first_state_coin_1.spent_height is None
+    assert first_state_coin_1.created_height is not None
+    first_state_coin_2 = first.items[1]
+    assert first_state_coin_2.spent_height is None
+    assert first_state_coin_2.created_height is not None
+    second = coin_update_messages[1]
+    assert second.fork_height == fork_height
+    assert len(second.items) == 2
+    second_state_coin_1 = second.items[0]
+    assert second_state_coin_1.spent_height is None
+    assert second_state_coin_1.created_height is None
+    second_state_coin_2 = second.items[1]
+    assert second_state_coin_2.spent_height is None
+    assert second_state_coin_2.created_height is None
+@pytest.mark.anyio
+async def test_subscribe_for_coin_id_reorg(simulator_and_wallet: OldSimulatorsAndWallets, self_hostname: str) -> None:
+    num_blocks = 4
+    long_blocks = 20
+    full_nodes, wallets, _ = simulator_and_wallet
+    full_node_api = full_nodes[0]
+    wallet_node, server_2 = wallets[0]
+    fn_server = full_node_api.full_node.server
+    standard_wallet = wallet_node.wallet_state_manager.wallets[uint32(1)]
+    assert isinstance(standard_wallet, Wallet)
+    puzzle_hash = await standard_wallet.get_new_puzzlehash()
+    await server_2.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
+    incoming_queue, peer_id = await add_dummy_connection(fn_server, self_hostname, 12312, NodeType.WALLET)
+    fake_wallet_peer = fn_server.all_connections[peer_id]
+    # Farm to create a coin that we'll track
+    for _ in range(num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
+    for _ in range(long_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
+    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(puzzle_hash))
+    for _ in range(num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
+    expected_height = uint32(long_blocks + 2 * num_blocks + 1)
+    await time_out_assert(20, full_node_api.full_node.blockchain.get_peak_height, expected_height)
+    coin_records = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(True, puzzle_hash)
+    assert len(coin_records) > 0
-        coin_update_messages = []
-        for message in all_messages:
-            if message.type == ProtocolMessageTypes.coin_state_update.value:
-                data_response: CoinStateUpdate = CoinStateUpdate.from_bytes(message.data)
-                coin_update_messages.append(data_response)
-        assert len(coin_update_messages) == 1
-        update = coin_update_messages[0]
-        coin_states = update.items
-        assert len(coin_states) == 2
-        first_coin = coin_states[0]
-        assert first_coin.spent_height is None
-        assert first_coin.created_height is None
-        second_coin = coin_states[1]
-        assert second_coin.spent_height is None
-        assert second_coin.created_height is None
-    @pytest.mark.anyio
-    async def test_subscribe_for_hint(self, simulator_and_wallet, self_hostname):
-        num_blocks = 4
-        full_nodes, wallets, bt = simulator_and_wallet
-        full_node_api = full_nodes[0]
-        wallet_node, server_2 = wallets[0]
-        fn_server = full_node_api.full_node.server
-        wsm: WalletStateManager = wallet_node.wallet_state_manager
-        await server_2.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
-        incoming_queue, peer_id = await add_dummy_connection(fn_server, self_hostname, 12312, NodeType.WALLET)
-        wt: WalletTool = bt.get_pool_wallet_tool()
-        ph = wt.get_new_puzzlehash()
-        for i in range(0, num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
-        await asyncio.sleep(6)
-        coins = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hashes(False, [ph])
-        coin_spent = coins[0].coin
-        hint_puzzle_hash = 32 * b"\2"
-        amount = 1
-        amount_bin = int_to_bytes(1)
-        hint = 32 * b"\5"
-        fake_wallet_peer = fn_server.all_connections[peer_id]
-        msg = wallet_protocol.RegisterForPhUpdates([hint], 0)
-        msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
-        assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
-        data_response: RespondToPhUpdates = RespondToCoinUpdates.from_bytes(msg_response.data)
-        assert len(data_response.coin_states) == 0
-        condition_dict = {
-            ConditionOpcode.CREATE_COIN: [
-                ConditionWithArgs(ConditionOpcode.CREATE_COIN, [hint_puzzle_hash, amount_bin, hint])
-            ]
-        }
-        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
-        tx: SpendBundle = wt.generate_signed_transaction(
-            10,
-            wt.get_new_puzzlehash(),
-            coin_spent,
-            condition_dic=condition_dict,
-        )
-        await full_node_api.respond_transaction(RespondTransaction(tx), fake_wallet_peer)
-        await full_node_api.process_spend_bundles(bundles=[tx])
-        all_messages = await get_all_messages_in_queue(incoming_queue)
+    for coin_rec in coin_records:
+        msg = wallet_protocol.RegisterForCoinUpdates([coin_rec.name], uint32(0))
+        msg_response = await full_node_api.register_interest_in_coin(msg, fake_wallet_peer)
+        assert msg_response is not None
+    fork_height = uint32(expected_height - num_blocks - 5)
+    req = ReorgProtocol(fork_height, uint32(expected_height + 5), zero_ph, None)
+    await full_node_api.reorg_from_index_to_new_index(req)
+    coin_records = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(True, puzzle_hash)
+    assert coin_records == []
+    all_messages = await get_all_messages_in_queue(incoming_queue)
+    coin_update_messages: List[CoinStateUpdate] = []
+    for message in all_messages:
+        if message.type == ProtocolMessageTypes.coin_state_update.value:
+            coin_state_update = CoinStateUpdate.from_bytes(message.data)
+            coin_update_messages.append(coin_state_update)
+    assert len(coin_update_messages) == 1
+    update = coin_update_messages[0]
+    coin_states = update.items
+    assert len(coin_states) == 2
+    first_coin = coin_states[0]
+    assert first_coin.spent_height is None
+    assert first_coin.created_height is None
+    second_coin = coin_states[1]
+    assert second_coin.spent_height is None
+    assert second_coin.created_height is None
+@pytest.mark.anyio
+async def test_subscribe_for_hint(simulator_and_wallet: OldSimulatorsAndWallets, self_hostname: str) -> None:
+    num_blocks = 4
+    full_nodes, wallets, bt = simulator_and_wallet
+    full_node_api = full_nodes[0]
+    wallet_node, server_2 = wallets[0]
+    fn_server = full_node_api.full_node.server
+    await server_2.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
+    incoming_queue, peer_id = await add_dummy_connection(fn_server, self_hostname, 12312, NodeType.WALLET)
+    wt = bt.get_pool_wallet_tool()
+    ph = wt.get_new_puzzlehash()
+    for _ in range(num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+    await asyncio.sleep(6)
+    coins = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hashes(False, [ph])
+    coin_spent = coins[0].coin
+    hint_puzzle_hash = 32 * b"\2"
-    amount = 1
+    amount = uint64(1)
+    amount_bin = int_to_bytes(1)
+    hint = bytes32(32 * b"\5")
+    fake_wallet_peer = fn_server.all_connections[peer_id]
+    msg = wallet_protocol.RegisterForPhUpdates([hint], uint32(0))
+    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
+    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
+    data_response = RespondToCoinUpdates.from_bytes(msg_response.data)
+    assert len(data_response.coin_states) == 0
+    condition_dict = {
+        ConditionOpcode.CREATE_COIN: [
+            ConditionWithArgs(ConditionOpcode.CREATE_COIN, [hint_puzzle_hash, amount_bin, hint])
+        ]
+    }
+    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
+    tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin_spent, condition_dic=condition_dict)
+    await full_node_api.respond_transaction(RespondTransaction(tx), fake_wallet_peer)
+    await full_node_api.process_spend_bundles(bundles=[tx])
+    all_messages = await get_all_messages_in_queue(incoming_queue)
+    notified_state = None
+    for message in all_messages:
+        if message.type == ProtocolMessageTypes.coin_state_update.value:
+            coin_state_update = CoinStateUpdate.from_bytes(message.data)
+            notified_state = coin_state_update
+            break
+    assert notified_state is not None
+    assert notified_state.items[0].coin == Coin(coin_spent.name(), hint_puzzle_hash, amount)
+    msg = wallet_protocol.RegisterForPhUpdates([hint], uint32(0))
+    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
+    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
+    response = RespondToCoinUpdates.from_bytes(msg_response.data)
+    # we have already subscribed to this puzzle hash. The full node will
+    # ignore the duplicate
+    assert response.coin_states == []
+@pytest.mark.anyio
+async def test_subscribe_for_puzzle_hash_coin_hint_duplicates(
+    simulator_and_wallet: OldSimulatorsAndWallets, self_hostname: str
+) -> None:
+    [full_node_api], [[_, wallet_server]], bt = simulator_and_wallet
+    full_node_server = full_node_api.full_node.server
+    await wallet_server.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    wt = bt.get_pool_wallet_tool()
+    ph = wt.get_new_puzzlehash()
+    await full_node_api.farm_blocks_to_puzzlehash(4, ph)
+    coins = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hashes(False, [ph])
+    wallet_connection = full_node_server.all_connections[wallet_server.node_id]
+    # Create a coin which is hinted with its own destination puzzle hash
+    tx = wt.generate_signed_transaction(
+        uint64(10),
+        wt.get_new_puzzlehash(),
+        coins[0].coin,
+        condition_dic={
+            ConditionOpcode.CREATE_COIN: [ConditionWithArgs(ConditionOpcode.CREATE_COIN, [ph, int_to_bytes(1), ph])]
+        },
+    )
+    await full_node_api.respond_transaction(RespondTransaction(tx), wallet_connection)
+    await full_node_api.process_spend_bundles(bundles=[tx])
+    # Query the coin states and make sure it doesn't contain duplicated entries
+    msg = wallet_protocol.RegisterForPhUpdates([ph], uint32(0))
+    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, wallet_connection)
+    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
+    response = RespondToCoinUpdates.from_bytes(msg_response.data)
+    assert len(response.coin_states) > 0
+    assert len(set(response.coin_states)) == len(response.coin_states)
+@pytest.mark.anyio
+async def test_subscribe_for_hint_long_sync(
+    wallet_two_node_simulator: OldSimulatorsAndWallets, self_hostname: str
+) -> None:
+    full_nodes, wallets, bt = wallet_two_node_simulator
+    full_node_api = full_nodes[0]
+    full_node_api_1 = full_nodes[1]
+    wallet_node, server_2 = wallets[0]
+    fn_server = full_node_api.full_node.server
+    fn_server_1 = full_node_api_1.full_node.server
+    await server_2.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
+    incoming_queue, peer_id = await add_dummy_connection(fn_server, self_hostname, 12312, NodeType.WALLET)
+    incoming_queue_1, peer_id_1 = await add_dummy_connection(fn_server_1, self_hostname, 12313, NodeType.WALLET)
+    wt = bt.get_pool_wallet_tool()
+    ph = wt.get_new_puzzlehash()
+    for _ in range(2):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+    coins = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hashes(False, [ph])
+    coin_spent = coins[0].coin
+    hint_puzzle_hash = 32 * b"\2"
-    amount = 1
+    amount = uint64(1)
+    amount_bin = int_to_bytes(1)
+    hint = bytes32(32 * b"\5")
+    fake_wallet_peer = fn_server.all_connections[peer_id]
+    fake_wallet_peer_1 = fn_server_1.all_connections[peer_id_1]
+    msg = wallet_protocol.RegisterForPhUpdates([hint], uint32(0))
+    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
+    await full_node_api_1.register_interest_in_puzzle_hash(msg, fake_wallet_peer_1)
+    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
+    data_response = RespondToCoinUpdates.from_bytes(msg_response.data)
+    assert len(data_response.coin_states) == 0
+    condition_dict = {
+        ConditionOpcode.CREATE_COIN: [
+            ConditionWithArgs(ConditionOpcode.CREATE_COIN, [hint_puzzle_hash, amount_bin, hint])
+        ]
+    }
+    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
+    tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin_spent, condition_dic=condition_dict)
+    await full_node_api.respond_transaction(RespondTransaction(tx), fake_wallet_peer)
+    await full_node_api.process_spend_bundles(bundles=[tx])
+    # Create more blocks than recent "short_sync_blocks_behind_threshold" so that node enters batch
+    blocks_to_farm = full_node_api.full_node.config.get("short_sync_blocks_behind_threshold", 100)
+    for _ in range(blocks_to_farm):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+    node1_height = full_node_api_1.full_node.blockchain.get_peak_height()
+    assert node1_height is None
+    await fn_server_1.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
+    node0_height = full_node_api.full_node.blockchain.get_peak_height()
+    await time_out_assert(60, full_node_api_1.full_node.blockchain.get_peak_height, node0_height)
+    all_messages = await get_all_messages_in_queue(incoming_queue)
+    all_messages_1 = await get_all_messages_in_queue(incoming_queue_1)
+    def check_messages_for_hint(messages: List[Message]) -> None:
         notified_state = None
-        for message in all_messages:
+        for message in messages:
             if message.type == ProtocolMessageTypes.coin_state_update.value:
-                data_response: CoinStateUpdate = CoinStateUpdate.from_bytes(message.data)
-                notified_state = data_response
+                coin_state_update = CoinStateUpdate.from_bytes(message.data)
+                notified_state = coin_state_update
                 break
         assert notified_state is not None

tests/wallet/test_debug_spend_bundle.py CHANGED Viewed

         @@@ -12,6 -12,6 +12,7 @@@ from chia.types.coin_spend import make_
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.spend_bundle import SpendBundle
 from chia.util.hash import std_hash
+from chia.util.ints import uint64
 from chia.wallet.util.debug_spend_bundle import debug_spend_bundle
         @@@ -22,9 -22,9 +23,9 @@@ def test_debug_spend_bundle() -> None
     sig = AugSchemeMPL.sign(sk, msg)
     ACS = Program.to(15).curry(Program.to("hey").curry("now")).curry("brown", "cow")
     ACS_PH = ACS.get_tree_hash()
-    coin: Coin = Coin(bytes32([0] * 32), ACS_PH, 3)
-    child_coin: Coin = Coin(coin.name(), ACS_PH, 0)
-    coin_bad_reveal: Coin = Coin(bytes32([0] * 32), bytes32([0] * 32), 0)
+    coin: Coin = Coin(bytes32([0] * 32), ACS_PH, uint64(3))
+    child_coin: Coin = Coin(coin.name(), ACS_PH, uint64(0))
+    coin_bad_reveal: Coin = Coin(bytes32([0] * 32), bytes32([0] * 32), uint64(0))
     solution = Program.to(
         [
             [ConditionOpcode.AGG_SIG_UNSAFE, pk, msg],

tests/wallet/test_sign_coin_spends.py CHANGED Viewed

         @@@ -10,10 -10,10 +10,10 @@@ from chia.types.blockchain_format.coin
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.types.coin_spend import CoinSpend
+from chia.types.coin_spend import CoinSpend, make_spend
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.util.db_wrapper import DBWrapper2, manage_connection
-from chia.util.ints import uint32
+from chia.util.ints import uint32, uint64
 from chia.wallet.derivation_record import DerivationRecord
 from chia.wallet.derive_keys import master_sk_to_wallet_sk, master_sk_to_wallet_sk_unhardened
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import (
         @@@ -45,15 -44,15 +45,15 @@@ msg2: bytes = b"msg2
 additional_data: bytes32 = bytes32(DEFAULT_CONSTANTS.AGG_SIG_ME_ADDITIONAL_DATA)
-coin: Coin = Coin(bytes32([0] * 32), bytes32([0] * 32), 0)
+coin: Coin = Coin(bytes32([0] * 32), bytes32([0] * 32), uint64(0))
 puzzle = SerializedProgram.from_bytes(b"\x01")
 solution_h = SerializedProgram.from_program(
-    Program.to([[ConditionOpcode.AGG_SIG_UNSAFE, pk1_h, msg1], [ConditionOpcode.AGG_SIG_ME, pk2_h, msg2]])
+    Program.to([[ConditionOpcode.AGG_SIG_UNSAFE, pk1_h, msg1], [ConditionOpcode.AGG_SIG_ME, pk2_h_synth, msg2]])
 )
 solution_u = SerializedProgram.from_program(
-    Program.to([[ConditionOpcode.AGG_SIG_UNSAFE, pk1_u, msg1], [ConditionOpcode.AGG_SIG_ME, pk2_u, msg2]])
+    Program.to([[ConditionOpcode.AGG_SIG_UNSAFE, pk1_u, msg1], [ConditionOpcode.AGG_SIG_ME, pk2_u_synth, msg2]])
 )
-spend_h: CoinSpend = CoinSpend(
+spend_h: CoinSpend = make_spend(
     coin,
     puzzle,
     solution_h,

tests/wallet/test_singleton.py CHANGED Viewed

         @@@ -74,7 -73,7 +74,7 @@@ def test_only_one_odd_coin_created() -
     solution = Program.to(
         [
             (singleton_mod_hash, (LAUNCHER_ID, LAUNCHER_PUZZLE_HASH)),
-            Program.to(binutils.assemble(clsp)),  # type: ignore[no-untyped-call]
-            Program.to(binutils.assemble("(q (51 0xcafef00d 203) (51 0xfadeddab 205))")),
+            Program.to(binutils.assemble(clsp)),
             [0xDEADBEEF, 0xCAFEF00D, 411],
             411,
             [],
         @@@ -88,7 -87,7 +88,7 @@@
     solution = Program.to(
         [
             (singleton_mod_hash, (LAUNCHER_ID, LAUNCHER_PUZZLE_HASH)),
-            Program.to(binutils.assemble(clsp)),  # type: ignore[no-untyped-call]
-            Program.to(binutils.assemble("(q (51 0xcafef00d 203) (51 0xfadeddab 204) (51 0xdeadbeef 202))")),
+            Program.to(binutils.assemble(clsp)),
             [0xDEADBEEF, 0xCAFEF00D, 411],
             411,
             [],

tests/wallet/test_singleton_lifecycle_fast.py CHANGED Viewed

         @@@ -1,7 -1,7 +1,7 @@@
 from __future__ import annotations
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Optional, Tuple, cast
-from typing import Any, Callable, Dict, List, Optional, Tuple
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, TypeVar, cast
 from chia_rs import G1Element, G2Element
 from clvm_tools import binutils
         @@@ -15,6 -15,6 +15,7 @@@ from chia.types.coin_spend import CoinS
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.spend_bundle import SpendBundle
 from chia.util.ints import uint32, uint64
+from chia.util.misc import satisfies_hint
 from chia.wallet.conditions import AssertCoinAnnouncement
 from chia.wallet.puzzles.load_clvm import load_clvm
 from chia.wallet.util.debug_spend_bundle import debug_spend_bundle
         @@@ -49,12 -49,12 +50,16 @@@ class PuzzleDB
         return self._db.get(puzzle_hash)
-def from_kwargs(kwargs: Dict[str, Any], key: str, type_info: Any = Any) -> Any:
-def from_kwargs(kwargs, key, type_info=Any):
+T = TypeVar("T")
+def from_kwargs(kwargs: Dict[str, Any], key: str, type_info: Type[T]) -> T:
     """Raise an exception if `kwargs[key]` is missing or the wrong type"""
-    """for now, we just check that it's present"""
     if key not in kwargs:
         raise ValueError(f"`{key}` missing in call to `solve`")
-    return kwargs[key]
+    if not satisfies_hint(kwargs[key], type_info):
+        raise TypeError(f"`{key}` must be of type {type_info} but is of type {type(kwargs[key])}")
+    return cast(T, kwargs[key])
 Solver_F = Callable[["Solver", PuzzleDB, List[Program], Any], Program]
         @@@ -92,16 -92,15 +97,16 @@@ class Solver
         raise ValueError("can't solve")
-def solve_launcher(solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict) -> Program:
-    launcher_amount = from_kwargs(kwargs, "launcher_amount", int)
+def solve_launcher(solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict[str, Any]) -> Program:
-    launcher_amount = from_kwargs(kwargs, "launcher_amount", int)
+    launcher_amount = from_kwargs(kwargs, "launcher_amount", uint64)
     destination_puzzle_hash = from_kwargs(kwargs, "destination_puzzle_hash", bytes32)
-    metadata = from_kwargs(kwargs, "metadata", List[Tuple[str, Program]])
+    metadata = from_kwargs(kwargs, "metadata", List[Tuple[str, str]])
     solution = Program.to([destination_puzzle_hash, launcher_amount, metadata])
-    return solution
+    # TODO: Remove cast when we improve typing
+    return cast(Program, solution)
-def solve_anyone_can_spend(solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict) -> Program:
+def solve_anyone_can_spend(solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict[str, Any]) -> Program:
     """
     This is the anyone-can-spend puzzle `1`. Note that farmers can easily steal this coin, so don't use
     it except for testing.
         @@@ -127,66 -124,58 +132,66 @@@ def solve_singleton(solver: Solver, puz
     `lineage_proof`: a `Program` that proves the parent is also a singleton (or the launcher).
     `coin_amount`: a necessarily-odd value of mojos in this coin.
     """
-    singleton_struct, inner_puzzle = args
+    _, inner_puzzle = args
     inner_solution = solver.solve(puzzle_db, inner_puzzle, **kwargs)
     lineage_proof = from_kwargs(kwargs, "lineage_proof", Program)
-    coin_amount = from_kwargs(kwargs, "coin_amount", int)
+    coin_amount = from_kwargs(kwargs, "coin_amount", uint64)
     solution = inner_solution.to([lineage_proof, coin_amount, inner_solution.rest()])
-    return solution
+    # TODO: Remove cast when we improve typing
+    return cast(Program, solution)
-def solve_pool_member(solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict) -> Program:
-    pool_member_spend_type = from_kwargs(kwargs, "pool_member_spend_type")
+def solve_pool_member(solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict[str, Any]) -> Program:
-    pool_member_spend_type = from_kwargs(kwargs, "pool_member_spend_type")
+    pool_member_spend_type = from_kwargs(kwargs, "pool_member_spend_type", str)
     allowable = ["to-waiting-room", "claim-p2-nft"]
     if pool_member_spend_type not in allowable:
         raise ValueError("`pool_member_spend_type` must be one of %s for POOL_MEMBER puzzle" % "/".join(allowable))
     to_waiting_room = pool_member_spend_type == "to-waiting-room"
     if to_waiting_room:
-        key_value_list = from_kwargs(kwargs, "key_value_list", List[Tuple[str, Program]])
-        return Program.to([0, 1, 0, 0, key_value_list])
+        key_value_list = from_kwargs(kwargs, "key_value_list", Program)
+        # TODO: Remove cast when we improve typing
+        return cast(Program, Program.to([0, 1, 0, 0, key_value_list]))
     # it's an "absorb_pool_reward" type
-    pool_reward_amount = from_kwargs(kwargs, "pool_reward_amount", int)
+    pool_reward_amount = from_kwargs(kwargs, "pool_reward_amount", uint64)
     pool_reward_height = from_kwargs(kwargs, "pool_reward_height", int)
     solution = Program.to([0, pool_reward_amount, pool_reward_height])
-    return solution
+    # TODO: Remove cast when we improve typing
+    return cast(Program, solution)
-def solve_pool_waiting_room(solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict) -> Program:
-    pool_leaving_spend_type = from_kwargs(kwargs, "pool_leaving_spend_type")
+def solve_pool_waiting_room(
+    solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict[str, Any]
+) -> Program:
-    pool_leaving_spend_type = from_kwargs(kwargs, "pool_leaving_spend_type")
+    pool_leaving_spend_type = from_kwargs(kwargs, "pool_leaving_spend_type", str)
     allowable = ["exit-waiting-room", "claim-p2-nft"]
     if pool_leaving_spend_type not in allowable:
         raise ValueError("`pool_leaving_spend_type` must be one of %s for POOL_MEMBER puzzle" % "/".join(allowable))
     exit_waiting_room = pool_leaving_spend_type == "exit-waiting-room"
     if exit_waiting_room:
-        key_value_list = from_kwargs(kwargs, "key_value_list", List[Tuple[str, Program]])
-        destination_puzzle_hash = from_kwargs(kwargs, "destination_puzzle_hash", int)
-        return Program.to([0, 1, key_value_list, destination_puzzle_hash])
+        key_value_list = from_kwargs(kwargs, "key_value_list", List[Tuple[str, str]])
+        destination_puzzle_hash = from_kwargs(kwargs, "destination_puzzle_hash", bytes32)
+        # TODO: Remove cast when we improve typing
+        return cast(Program, Program.to([0, 1, key_value_list, destination_puzzle_hash]))
     # it's an "absorb_pool_reward" type
-    pool_reward_amount = from_kwargs(kwargs, "pool_reward_amount", int)
+    pool_reward_amount = from_kwargs(kwargs, "pool_reward_amount", uint64)
     pool_reward_height = from_kwargs(kwargs, "pool_reward_height", int)
     solution = Program.to([0, 0, pool_reward_amount, pool_reward_height])
-    return solution
+    # TODO: Remove cast when we improve typing
+    return cast(Program, solution)
-def solve_p2_singleton(solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict) -> Program:
-    p2_singleton_spend_type = from_kwargs(kwargs, "p2_singleton_spend_type")
+def solve_p2_singleton(solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict[str, Any]) -> Program:
-    p2_singleton_spend_type = from_kwargs(kwargs, "p2_singleton_spend_type")
+    p2_singleton_spend_type = from_kwargs(kwargs, "p2_singleton_spend_type", str)
     allowable = ["claim-p2-nft", "delayed-spend"]
     if p2_singleton_spend_type not in allowable:
         raise ValueError("`p2_singleton_spend_type` must be one of %s for P2_SINGLETON puzzle" % "/".join(allowable))
     claim_p2_nft = p2_singleton_spend_type == "claim-p2-nft"
     if claim_p2_nft:
-        singleton_inner_puzzle_hash = from_kwargs(kwargs, "singleton_inner_puzzle_hash")
-        p2_singleton_coin_name = from_kwargs(kwargs, "p2_singleton_coin_name")
+        singleton_inner_puzzle_hash = from_kwargs(kwargs, "singleton_inner_puzzle_hash", bytes32)
+        p2_singleton_coin_name = from_kwargs(kwargs, "p2_singleton_coin_name", bytes)
         solution = Program.to([singleton_inner_puzzle_hash, p2_singleton_coin_name])
-        return solution
+        # TODO: Remove cast when we improve typing
+        return cast(Program, solution)
     raise ValueError("can't solve `delayed-spend` yet")
         @@@ -268,9 -258,7 +273,9 @@@ def adaptor_for_singleton_inner_puzzle(
     puzzle to work as a singleton inner puzzle.
     """
     # this is pretty slow and lame
-    program = binutils.assemble("(a (q . %s) 3)" % binutils.disassemble(puzzle))  # type: ignore[no-untyped-call]
-    return Program.to(binutils.assemble("(a (q . %s) 3)" % binutils.disassemble(puzzle)))
+    program = binutils.assemble("(a (q . %s) 3)" % binutils.disassemble(puzzle))
+    # TODO: Remove cast when we improve typing
+    return cast(Program, Program.to(program))
 def launcher_conditions_and_spend_bundle(
         @@@ -290,13 -277,21 +295,13 @@@
     singleton_full_puzzle_hash = singleton_full_puzzle.get_tree_hash()
     message_program = Program.to([singleton_full_puzzle_hash, launcher_amount, metadata])
     expected_announcement = AssertCoinAnnouncement(
-        asserted_id=launcher_coin.name(), asserted_msg=message_program.get_tree_hash()
+        asserted_id=launcher_id, asserted_msg=message_program.get_tree_hash()
     )
     expected_conditions = []
-    expected_conditions.append(
-        Program.to(
-            binutils.assemble(
-                f"(0x{ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT.hex()} 0x{expected_announcement.msg_calc})"
-            )
-        )
-    )
-    expected_conditions.append(
-        Program.to(
-            binutils.assemble(f"(0x{ConditionOpcode.CREATE_COIN.hex()} 0x{launcher_puzzle_hash} {launcher_amount})")
-        )
-    )
+    clsp = f"(0x{ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT.hex()} 0x{expected_announcement.msg_calc})"
-    expected_conditions.append(Program.to(binutils.assemble(clsp)))  # type: ignore[no-untyped-call]
+    expected_conditions.append(Program.to(binutils.assemble(clsp)))
+    clsp = f"(0x{ConditionOpcode.CREATE_COIN.hex()} 0x{launcher_puzzle_hash} {launcher_amount})"
-    expected_conditions.append(Program.to(binutils.assemble(clsp)))  # type: ignore[no-untyped-call]
+    expected_conditions.append(Program.to(binutils.assemble(clsp)))
     solution = solve_puzzle(
         puzzle_db,
         launcher_puzzle,
         @@@ -737,7 -741,7 +742,7 @@@ def test_lifecycle_with_coinstore_as_wa
     # now spend to oblivion with the `-113` hack
     coin_spend = SINGLETON_WALLET.coin_spend_for_conditions(
-        PUZZLE_DB, conditions=[[ConditionOpcode.CREATE_COIN, 0, -113]]
+        PUZZLE_DB, conditions=[Program.to([ConditionOpcode.CREATE_COIN, 0, -113])]
     )
     spend_bundle = SpendBundle([coin_spend], G2Element())
     debug_spend_bundle(spend_bundle)

tests/wallet/test_singleton_store.py CHANGED Viewed

         @@@ -25,7 -25,7 +25,7 @@@ def get_record(wallet_id: uint32 = uint
     inner_puz_hash = inner_puz.get_tree_hash()
     parent_puz = create_singleton_puzzle(inner_puz, launcher_id)
     parent_puz_hash = parent_puz.get_tree_hash()
-    parent_coin = Coin(launcher_id, parent_puz_hash, 1)
+    parent_coin = Coin(launcher_id, parent_puz_hash, uint64(1))
     inner_sol = Program.to([[51, inner_puz_hash, 1]])
     lineage_proof = LineageProof(launcher_id, inner_puz.get_tree_hash(), uint64(1))
     parent_sol = Program.to([lineage_proof.to_program(), 1, inner_sol])
         @@@ -71,7 -71,7 +71,7 @@@ class TestSingletonStore
         async with DBConnection(1) as wrapper:
             db = await WalletSingletonStore.create(wrapper)
             record = get_record()
-            child_coin = Coin(record.coin.name(), record.coin.puzzle_hash, 1)
+            child_coin = Coin(record.coin.name(), record.coin.puzzle_hash, uint64(1))
             parent_coinspend = record.parent_coinspend
             # test add spend
         @@@ -82,9 -82,9 +82,9 @@@
             # Test adding a non-singleton will fail
             inner_puz = Program.to(1)
             inner_puz_hash = inner_puz.get_tree_hash()
-            bad_coin = Coin(record.singleton_id, inner_puz_hash, 1)
+            bad_coin = Coin(record.singleton_id, inner_puz_hash, uint64(1))
             inner_sol = Program.to([[51, inner_puz_hash, 1]])
-            bad_coinspend = CoinSpend(bad_coin, inner_puz, inner_sol)
+            bad_coinspend = make_spend(bad_coin, inner_puz, inner_sol)
             with pytest.raises(RuntimeError) as e_info:
                 await db.add_spend(uint32(2), bad_coinspend, uint32(10))
             assert e_info.value.args[0] == "Coin to add is not a valid singleton"

tests/wallet/test_wallet_node.py CHANGED Viewed

         @@@ -500,7 -500,7 +500,7 @@@ async def test_add_states_from_peer_unt
     wallet_node._close()
     coin_generator = CoinGenerator()
     # Generate enough coin states to fill up the max number validation/add tasks.
-    coin_states = [CoinState(coin_generator.get().coin, i, i) for i in range(3000)]
+    coin_states = [CoinState(coin_generator.get().coin, uint32(i), uint32(i)) for i in range(3000)]
     with caplog.at_level(logging.INFO):
         assert not await wallet_node.add_states_from_peer(coin_states, list(wallet_server.all_connections.values())[0])
         assert "Terminating receipt and validation due to shut down request" in caplog.text

tests/wallet/test_wallet_state_manager.py CHANGED Viewed

         @@@ -10,7 -10,8 +10,7 @@@ from chia.server.outbound_message impor
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.peer_info import PeerInfo
-from chia.util.ints import uint32
+from chia.util.ints import uint32, uint64
 from chia.wallet.derivation_record import DerivationRecord
 from chia.wallet.derive_keys import master_sk_to_wallet_sk, master_sk_to_wallet_sk_unhardened
 from chia.wallet.util.wallet_types import WalletType
         @@@ -93,5 -93,5 +93,5 @@@ async def test_determine_coin_type(simu
     wallet_state_manager: WalletStateManager = wallet_node.wallet_state_manager
     peer = wallet_node.server.get_connections(NodeType.FULL_NODE)[0]
     assert (None, None) == await wallet_state_manager.determine_coin_type(
-        peer, CoinState(Coin(bytes32(b"1" * 32), bytes32(b"1" * 32), 0), uint32(0), uint32(0)), None
+        peer, CoinState(Coin(bytes32(b"1" * 32), bytes32(b"1" * 32), uint64(0)), uint32(0), uint32(0)), None
     )

tests/wallet/test_wallet_utils.py CHANGED Viewed

         @@@ -6,19 -6,19 +6,19 @@@ import pytes
 from chia_rs import Coin, CoinState
 from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.util.ints import uint64
+from chia.util.ints import uint32, uint64
 from chia.wallet.util.peer_request_cache import PeerRequestCache
 from chia.wallet.util.wallet_sync_utils import sort_coin_states
 coin_states = [
     CoinState(Coin(bytes32(b"\00" * 32), bytes32(b"\00" * 32), uint64(1)), None, None),
-    CoinState(Coin(bytes32(b"\00" * 32), bytes32(b"\11" * 32), uint64(1)), None, 1),
-    CoinState(Coin(bytes32(b"\00" * 32), bytes32(b"\22" * 32), uint64(1)), 1, 1),
-    CoinState(Coin(bytes32(b"\00" * 32), bytes32(b"\33" * 32), uint64(1)), 1, 1),
-    CoinState(Coin(bytes32(b"\00" * 32), bytes32(b"\44" * 32), uint64(1)), 2, 1),
-    CoinState(Coin(bytes32(b"\00" * 32), bytes32(b"\55" * 32), uint64(1)), 2, 2),
-    CoinState(Coin(bytes32(b"\00" * 32), bytes32(b"\66" * 32), uint64(1)), 20, 10),
-    CoinState(Coin(bytes32(b"\00" * 32), bytes32(b"\77" * 32), uint64(1)), None, 20),
+    CoinState(Coin(bytes32(b"\00" * 32), bytes32(b"\11" * 32), uint64(1)), None, uint32(1)),
+    CoinState(Coin(bytes32(b"\00" * 32), bytes32(b"\22" * 32), uint64(1)), uint32(1), uint32(1)),
+    CoinState(Coin(bytes32(b"\00" * 32), bytes32(b"\33" * 32), uint64(1)), uint32(1), uint32(1)),
+    CoinState(Coin(bytes32(b"\00" * 32), bytes32(b"\44" * 32), uint64(1)), uint32(2), uint32(1)),
+    CoinState(Coin(bytes32(b"\00" * 32), bytes32(b"\55" * 32), uint64(1)), uint32(2), uint32(2)),
+    CoinState(Coin(bytes32(b"\00" * 32), bytes32(b"\66" * 32), uint64(1)), uint32(20), uint32(10)),
+    CoinState(Coin(bytes32(b"\00" * 32), bytes32(b"\77" * 32), uint64(1)), None, uint32(20)),
 ]
         @@@ -32,7 -32,7 +32,11 @@@ def assert_race_cache(cache: PeerReques
 def dummy_coin_state(*, created_height: Optional[int], spent_height: Optional[int]) -> CoinState:
-    return CoinState(Coin(bytes(b"0" * 32), bytes(b"0" * 32), 0), spent_height, created_height)
+    return CoinState(
+        Coin(bytes(b"0" * 32), bytes(b"0" * 32), uint64(0)),
+        uint32.construct_optional(spent_height),
+        uint32.construct_optional(created_height),
+    )
 def heights(coin_states: Collection[CoinState]) -> List[Tuple[Optional[int], Optional[int]]]: